lael-labs/linux

arch/mips/include/asm/octeon/cvmx.h+2−2

@@ -154,13 +154,13 @@ static inline uint64_t cvmx_build_bits(uint64_t high_bit, · 153 unmodified lines
154		154
155	/**	155	/**
156	* Convert a memory pointer (void*) into a hardware compatible	156	* Convert a memory pointer (void*) into a hardware compatible
157	* memory address (uint64_t). Octeon hardware widgets don't	157	* memory address (phys_addr_t). Octeon hardware widgets don't
158	* understand logical addresses.	158	* understand logical addresses.
159	*	159	*
160	* @ptr: C style memory pointer	160	* @ptr: C style memory pointer
161	* Returns Hardware physical address	161	* Returns Hardware physical address
162	*/	162	*/
163	static inline uint64_t cvmx_ptr_to_phys(void *ptr)	163	static inline phys_addr_t cvmx_ptr_to_phys(void *ptr)
164	{	164	{
165	if (sizeof(void *) == 8) {	165	if (sizeof(void *) == 8) {
166	/*	166	/*

drivers/staging/emxx_udc/emxx_udc.c+1−4

 	/* MAX Packet Size */
 	mpkt = _nbu2ss_readl(&preg->EP_REGS[num].EP_PCKT_ADRS) & EPN_MPKT;
-	if ((DMA_MAX_COUNT * mpkt) < length)
+	i_write_length = min(DMA_MAX_COUNT * mpkt, length);
-		i_write_length = DMA_MAX_COUNT * mpkt;
-	else
-		i_write_length = length;
 	/*------------------------------------------------------------*/
 	/* Number of transmission packets */

drivers/staging/fieldbus/dev_core.c+7−10

 {
 	struct fieldbus_dev *fb = dev_get_drvdata(dev);
-	return sprintf(buf, "%d\n", !!fb->online);
+	return sysfs_emit(buf, "%d\n", !!fb->online);
 }
 static DEVICE_ATTR_RO(online);
 	if (!fb->enable_get)
 		return -EINVAL;
-	return sprintf(buf, "%d\n", !!fb->enable_get(fb));
+	return sysfs_emit(buf, "%d\n", !!fb->enable_get(fb));
 }
 static ssize_t enabled_store(struct device *dev, struct device_attribute *attr,
 {
 	struct fieldbus_dev *fb = dev_get_drvdata(dev);
-	/*
+	/* card_name was provided by child driver. */
-	 * card_name was provided by child driver, could potentially be long.
+	return sysfs_emit(buf, "%s\n", fb->card_name);
-	 * protect against buffer overrun.
-	 */
-	return snprintf(buf, PAGE_SIZE, "%s\n", fb->card_name);
 }
 static DEVICE_ATTR_RO(card_name);
 {
 	struct fieldbus_dev *fb = dev_get_drvdata(dev);
-	return sprintf(buf, "%zu\n", fb->read_area_sz);
+	return sysfs_emit(buf, "%zu\n", fb->read_area_sz);
 }
 static DEVICE_ATTR_RO(read_area_size);
 {
 	struct fieldbus_dev *fb = dev_get_drvdata(dev);
-	return sprintf(buf, "%zu\n", fb->write_area_sz);
+	return sysfs_emit(buf, "%zu\n", fb->write_area_sz);
 }
 static DEVICE_ATTR_RO(write_area_size);
 		break;
 	}
-	return sprintf(buf, "%s\n", t);
+	return sysfs_emit(buf, "%s\n", t);
 }
 static DEVICE_ATTR_RO(fieldbus_type);

drivers/staging/gdm724x/gdm_tty.c+8−5

 #define MUX_TX_MAX_SIZE 2048
-#define GDM_TTY_READY(gdm) (gdm && gdm->tty_dev && gdm->port.count)
+static inline bool gdm_tty_ready(struct gdm *gdm)
+{
+	return gdm && gdm->tty_dev && gdm->port.count;
+}
 static struct tty_driver *gdm_driver[TTY_MAX_COUNT];
 static struct gdm *gdm_table[TTY_MAX_COUNT][GDM_TTY_MINOR];
 {
 	struct gdm *gdm = tty_dev->gdm[index];
-	if (!GDM_TTY_READY(gdm)) {
+	if (!gdm_tty_ready(gdm)) {
 		if (complete == RECV_PACKET_PROCESS_COMPLETE)
 			gdm->tty_dev->recv_func(gdm->tty_dev->priv_dev,
 						gdm_tty_recv_complete);
 {
 	struct gdm *gdm = arg;
-	if (!GDM_TTY_READY(gdm))
+	if (!gdm_tty_ready(gdm))
 		return;
 	tty_port_tty_wakeup(&gdm->port);
 	int sent_len = 0;
 	int sending_len = 0;
-	if (!GDM_TTY_READY(gdm))
+	if (!gdm_tty_ready(gdm))
 		return -ENODEV;
 	if (!len)
 {
 	struct gdm *gdm = tty->driver_data;
-	if (!GDM_TTY_READY(gdm))
+	if (!gdm_tty_ready(gdm))
 		return 0;
 	return WRITE_SIZE;

drivers/staging/greybus/tools/loopback_test.c+1−14

 	for (i = 0; i < t->device_count; i++)
 		printf("device[%d] = %s\n", i, t->devices[i].name);
 }
 int open_sysfs(const char *sys_pfx, const char *node, int flags)
 	char buf[SYSFS_MAX_INT];
 	if (read(fd, buf, sizeof(buf)) < 0) {
 		fprintf(stderr, "unable to read from %s%s %s\n", sys_pfx, node,
 			strerror(errno));
 		close(fd);
 			r->apbridge_unipro_latency_max - r->apbridge_unipro_latency_min;
 		r->gbphy_firmware_latency_jitter =
 			r->gbphy_firmware_latency_max - r->gbphy_firmware_latency_min;
 	}
 	/*calculate the aggregate results of all enabled devices */
 			r->apbridge_unipro_latency_max - r->apbridge_unipro_latency_min;
 		r->gbphy_firmware_latency_jitter =
 			r->gbphy_firmware_latency_max - r->gbphy_firmware_latency_min;
 	}
 	return 0;
 			fprintf(stderr, "unable to open %s for appending\n", file_name);
 			abort();
 		}
 	}
 	for (i = 0; i < t->device_count; i++) {
 		if (!device_enabled(t, i))
 			if (ret == -1)
 				fprintf(stderr, "unable to write %d bytes to csv.\n", len);
 		}
 	}
 	if (t->aggregate_output) {
 		len = format_output(t, &t->aggregate_results, "aggregate",
 				    data, sizeof(data), &tm);
 static int close_poll_files(struct loopback_test *t)
 {
 	int i;
 	for (i = 0; i < t->poll_count; i++)
 		close(t->fds[i].fd);
 		ts = &t->poll_timeout;
 	while (1) {
 		ret = ppoll(t->fds, t->poll_count, ts, &mask_old);
 		if (ret <= 0) {
 			stop_tests(t);
 		if (t->stop_all || device_enabled(t, i))
 			write_sysfs_val(t->devices[i].sysfs_entry, "type", 0);
 	for (i = 0; i < t->device_count; i++) {
 		if (!device_enabled(t, i))
 			continue;
 	return 0;
 }
 void loopback_run(struct loopback_test *t)
 {
 	int i;
 	if (ret)
 		goto err;
 	get_results(t);
 	log_results(t);
 err:
 	printf("Error running test\n");
-	return;
 }
 static int sanity_check(struct loopback_test *t)
 			fprintf(stderr, "Bad device mask %x\n", (1 << i));
 			return -1;
 		}
 	}
 	return 0;
 }

drivers/staging/iio/frequency/ad9834.c+2−4

 static IIO_DEV_ATTR_PHASESYMBOL(0, 0200, NULL, ad9834_write, AD9834_PSEL);
 static IIO_CONST_ATTR_PHASE_SCALE(0, "0.0015339808"); /* 2PI/2^12 rad*/
-static IIO_DEV_ATTR_PINCONTROL_EN(0, 0200, NULL,
+static IIO_DEV_ATTR_PINCONTROL_EN(0, 0200, NULL, ad9834_write, AD9834_PIN_SW);
-	ad9834_write, AD9834_PIN_SW);
 static IIO_DEV_ATTR_OUT_ENABLE(0, 0200, NULL, ad9834_write, AD9834_RESET);
-static IIO_DEV_ATTR_OUTY_ENABLE(0, 1, 0200, NULL,
+static IIO_DEV_ATTR_OUTY_ENABLE(0, 1, 0200, NULL, ad9834_write, AD9834_OPBITEN);
-	ad9834_write, AD9834_OPBITEN);
 static IIO_DEV_ATTR_OUT_WAVETYPE(0, 0, ad9834_store_wavetype, 0);
 static IIO_DEV_ATTR_OUT_WAVETYPE(0, 1, ad9834_store_wavetype, 1);

drivers/staging/iio/meter/ade7854-i2c.c+2−3

 	return ret;
 }
-static int ade7854_i2c_probe(struct i2c_client *client,
+static int ade7854_i2c_probe(struct i2c_client *client)
-			     const struct i2c_device_id *id)
 {
 	struct ade7854_state *st;
 	struct iio_dev *indio_dev;
 	.driver = {
 		.name = "ade7854",
 	},
-	.probe    = ade7854_i2c_probe,
+	.probe_new = ade7854_i2c_probe,
 	.id_table = ade7854_id,
 };
 module_i2c_driver(ade7854_i2c_driver);

drivers/staging/ks7010/TODO+3−0

 - fix the 'card removal' event when card is inserted when booting
 - check what other upstream wireless mechanisms can be used instead of the
   custom ones here
+- Switch to use LIB80211.
+- Switch to use MAC80211.
+- Switch to use CFG80211.
 Please send any patches to:
 Greg Kroah-Hartman <gregkh@linuxfoundation.org>

drivers/staging/ks7010/ks_wlan_net.c+126−122

 }
 static int ks_wlan_set_stop_request(struct net_device *dev,
-				    struct iw_request_info *info, __u32 *uwrq,
+				    struct iw_request_info *info,
-				    char *extra)
+				    union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 		return -EPERM;
 	/* for SLEEP MODE */
-	if (!(*uwrq))
+	if (!(uwrq->mode))
 		return -EINVAL;
 	hostif_sme_enqueue(priv, SME_STOP_REQUEST);
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	struct iw_mlme *mlme = (struct iw_mlme *)extra;
-	__u32 mode = 1;
+	union iwreq_data uwrq;
+	uwrq.mode = 1;
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	    mlme->reason_code == WLAN_REASON_MIC_FAILURE)
 		return 0;
-	return ks_wlan_set_stop_request(dev, NULL, &mode, NULL);
+	return ks_wlan_set_stop_request(dev, NULL, &uwrq, NULL);
 }
 static int ks_wlan_get_firmware_version(struct net_device *dev,
 					struct iw_request_info *info,
-					struct iw_point *dwrq, char *extra)
+					union iwreq_data *uwrq, char *extra)
 {
+	struct iw_point *dwrq = &uwrq->data;
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	dwrq->length = priv->version_size + 1;
 }
 static int ks_wlan_set_preamble(struct net_device *dev,
-				struct iw_request_info *info, __u32 *uwrq,
+				struct iw_request_info *info,
-				char *extra)
+				union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 		return -EPERM;
 	/* for SLEEP MODE */
-	if (*uwrq != LONG_PREAMBLE && *uwrq != SHORT_PREAMBLE)
+	if (uwrq->mode != LONG_PREAMBLE && uwrq->mode != SHORT_PREAMBLE)
 		return -EINVAL;
-	priv->reg.preamble = *uwrq;
+	priv->reg.preamble = uwrq->mode;
 	priv->need_commit |= SME_MODE_SET;
 	return -EINPROGRESS;	/* Call commit handler */
 }
 static int ks_wlan_get_preamble(struct net_device *dev,
-				struct iw_request_info *info, __u32 *uwrq,
+				struct iw_request_info *info,
-				char *extra)
+				union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 		return -EPERM;
 	/* for SLEEP MODE */
-	*uwrq = priv->reg.preamble;
+	uwrq->mode = priv->reg.preamble;
 	return 0;
 }
 static int ks_wlan_set_power_mgmt(struct net_device *dev,
-				  struct iw_request_info *info, __u32 *uwrq,
+				  struct iw_request_info *info,
-				  char *extra)
+				  union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
-	if (*uwrq != POWER_MGMT_ACTIVE &&
+	if (uwrq->mode != POWER_MGMT_ACTIVE &&
-	    *uwrq != POWER_MGMT_SAVE1 &&
+	    uwrq->mode != POWER_MGMT_SAVE1 &&
-	    *uwrq != POWER_MGMT_SAVE2)
+	    uwrq->mode != POWER_MGMT_SAVE2)
 		return -EINVAL;
-	if ((*uwrq == POWER_MGMT_SAVE1 || *uwrq == POWER_MGMT_SAVE2) &&
+	if ((uwrq->mode == POWER_MGMT_SAVE1 || uwrq->mode == POWER_MGMT_SAVE2) &&
 	    (priv->reg.operation_mode != MODE_INFRASTRUCTURE))
 		return -EINVAL;
-	priv->reg.power_mgmt = *uwrq;
+	priv->reg.power_mgmt = uwrq->mode;
 	hostif_sme_enqueue(priv, SME_POW_MNGMT_REQUEST);
 	return 0;
 }
 static int ks_wlan_get_power_mgmt(struct net_device *dev,
-				  struct iw_request_info *info, __u32 *uwrq,
+				  struct iw_request_info *info,
-				  char *extra)
+				  union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 		return -EPERM;
 	/* for SLEEP MODE */
-	*uwrq = priv->reg.power_mgmt;
+	uwrq->mode = priv->reg.power_mgmt;
 	return 0;
 }
 static int ks_wlan_set_scan_type(struct net_device *dev,
-				 struct iw_request_info *info, __u32 *uwrq,
+				 struct iw_request_info *info,
-				 char *extra)
+				 union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 		return -EPERM;
 	/* for SLEEP MODE */
-	if (*uwrq != ACTIVE_SCAN && *uwrq != PASSIVE_SCAN)
+	if (uwrq->mode != ACTIVE_SCAN && uwrq->mode != PASSIVE_SCAN)
 		return -EINVAL;
-	priv->reg.scan_type = *uwrq;
+	priv->reg.scan_type = uwrq->mode;
 	return 0;
 }
 static int ks_wlan_get_scan_type(struct net_device *dev,
-				 struct iw_request_info *info, __u32 *uwrq,
+				 struct iw_request_info *info,
-				 char *extra)
+				 union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	*uwrq = priv->reg.scan_type;
+	uwrq->mode = priv->reg.scan_type;
 	return 0;
 }
 static int ks_wlan_set_beacon_lost(struct net_device *dev,
-				   struct iw_request_info *info, __u32 *uwrq,
+				   struct iw_request_info *info,
-				   char *extra)
+				   union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	if (*uwrq > BEACON_LOST_COUNT_MAX)
+	if (uwrq->mode > BEACON_LOST_COUNT_MAX)
 		return -EINVAL;
-	priv->reg.beacon_lost_count = *uwrq;
+	priv->reg.beacon_lost_count = uwrq->mode;
 	if (priv->reg.operation_mode == MODE_INFRASTRUCTURE) {
 		priv->need_commit |= SME_MODE_SET;
 }
 static int ks_wlan_get_beacon_lost(struct net_device *dev,
-				   struct iw_request_info *info, __u32 *uwrq,
+				   struct iw_request_info *info,
-				   char *extra)
+				   union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	*uwrq = priv->reg.beacon_lost_count;
+	uwrq->mode = priv->reg.beacon_lost_count;
 	return 0;
 }
 static int ks_wlan_set_phy_type(struct net_device *dev,
-				struct iw_request_info *info, __u32 *uwrq,
+				struct iw_request_info *info,
-				char *extra)
+				union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
-	if (*uwrq != D_11B_ONLY_MODE &&
+	if (uwrq->mode != D_11B_ONLY_MODE &&
-	    *uwrq != D_11G_ONLY_MODE &&
+	    uwrq->mode != D_11G_ONLY_MODE &&
-	    *uwrq != D_11BG_COMPATIBLE_MODE)
+	    uwrq->mode != D_11BG_COMPATIBLE_MODE)
 		return -EINVAL;
 	/* for SLEEP MODE */
-	priv->reg.phy_type = *uwrq;
+	priv->reg.phy_type = uwrq->mode;
 	priv->need_commit |= SME_MODE_SET;
 	return -EINPROGRESS;	/* Call commit handler */
 }
 static int ks_wlan_get_phy_type(struct net_device *dev,
-				struct iw_request_info *info, __u32 *uwrq,
+				struct iw_request_info *info,
-				char *extra)
+				union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	*uwrq = priv->reg.phy_type;
+	uwrq->mode = priv->reg.phy_type;
 	return 0;
 }
 static int ks_wlan_set_cts_mode(struct net_device *dev,
-				struct iw_request_info *info, __u32 *uwrq,
+				struct iw_request_info *info,
-				char *extra)
+				union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	if (*uwrq != CTS_MODE_FALSE && *uwrq != CTS_MODE_TRUE)
+	if (uwrq->mode != CTS_MODE_FALSE && uwrq->mode != CTS_MODE_TRUE)
 		return -EINVAL;
-	priv->reg.cts_mode = (*uwrq == CTS_MODE_FALSE) ? *uwrq :
+	priv->reg.cts_mode = (uwrq->mode == CTS_MODE_FALSE) ? uwrq->mode :
 			      (priv->reg.phy_type == D_11G_ONLY_MODE ||
 			       priv->reg.phy_type == D_11BG_COMPATIBLE_MODE) ?
-			       *uwrq : !*uwrq;
+			       uwrq->mode : !uwrq->mode;
 	priv->need_commit |= SME_MODE_SET;
 	return -EINPROGRESS;	/* Call commit handler */
 }
 static int ks_wlan_get_cts_mode(struct net_device *dev,
-				struct iw_request_info *info, __u32 *uwrq,
+				struct iw_request_info *info,
-				char *extra)
+				union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	*uwrq = priv->reg.cts_mode;
+	uwrq->mode = priv->reg.cts_mode;
 	return 0;
 }
 static int ks_wlan_set_sleep_mode(struct net_device *dev,
 				  struct iw_request_info *info,
-				  __u32 *uwrq, char *extra)
+				  union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
-	if (*uwrq != SLP_SLEEP &&
+	if (uwrq->mode != SLP_SLEEP &&
-	    *uwrq != SLP_ACTIVE) {
+	    uwrq->mode != SLP_ACTIVE) {
-		netdev_err(dev, "SET_SLEEP_MODE %d error\n", *uwrq);
+		netdev_err(dev, "SET_SLEEP_MODE %d error\n", uwrq->mode);
 		return -EINVAL;
 	}
-	priv->sleep_mode = *uwrq;
+	priv->sleep_mode = uwrq->mode;
 	netdev_info(dev, "SET_SLEEP_MODE %d\n", priv->sleep_mode);
-	if (*uwrq == SLP_SLEEP)
+	if (uwrq->mode == SLP_SLEEP)
 		hostif_sme_enqueue(priv, SME_STOP_REQUEST);
 	hostif_sme_enqueue(priv, SME_SLEEP_REQUEST);
 static int ks_wlan_get_sleep_mode(struct net_device *dev,
 				  struct iw_request_info *info,
-				  __u32 *uwrq, char *extra)
+				  union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
-	*uwrq = priv->sleep_mode;
+	uwrq->mode = priv->sleep_mode;
 	return 0;
 }
 static int ks_wlan_set_wps_enable(struct net_device *dev,
-				  struct iw_request_info *info, __u32 *uwrq,
+				  struct iw_request_info *info,
-				  char *extra)
+				  union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	if (*uwrq != 0 && *uwrq != 1)
+	if (uwrq->mode != 0 && uwrq->mode != 1)
 		return -EINVAL;
-	priv->wps.wps_enabled = *uwrq;
+	priv->wps.wps_enabled = uwrq->mode;
 	hostif_sme_enqueue(priv, SME_WPS_ENABLE_REQUEST);
 	return 0;
 }
 static int ks_wlan_get_wps_enable(struct net_device *dev,
-				  struct iw_request_info *info, __u32 *uwrq,
+				  struct iw_request_info *info,
-				  char *extra)
+				  union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	*uwrq = priv->wps.wps_enabled;
+	uwrq->mode = priv->wps.wps_enabled;
-	netdev_info(dev, "return=%d\n", *uwrq);
+	netdev_info(dev, "return=%d\n", uwrq->mode);
 	return 0;
 }
 static int ks_wlan_set_wps_probe_req(struct net_device *dev,
 				     struct iw_request_info *info,
-				     struct iw_point *dwrq, char *extra)
+				     union iwreq_data *uwrq, char *extra)
 {
+	struct iw_point *dwrq = &uwrq->data;
 	u8 *p = extra;
 	unsigned char len;
 	struct ks_wlan_private *priv = netdev_priv(dev);
 }
 static int ks_wlan_set_tx_gain(struct net_device *dev,
-			       struct iw_request_info *info, __u32 *uwrq,
+			       struct iw_request_info *info,
-			       char *extra)
+			       union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	if (*uwrq > 0xFF)
+	if (uwrq->mode > 0xFF)
 		return -EINVAL;
-	priv->gain.tx_gain = (u8)*uwrq;
+	priv->gain.tx_gain = (u8)uwrq->mode;
 	priv->gain.tx_mode = (priv->gain.tx_gain < 0xFF) ? 1 : 0;
 	hostif_sme_enqueue(priv, SME_SET_GAIN);
 	return 0;
 }
 static int ks_wlan_get_tx_gain(struct net_device *dev,
-			       struct iw_request_info *info, __u32 *uwrq,
+			       struct iw_request_info *info,
-			       char *extra)
+			       union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	*uwrq = priv->gain.tx_gain;
+	uwrq->mode = priv->gain.tx_gain;
 	hostif_sme_enqueue(priv, SME_GET_GAIN);
 	return 0;
 }
 static int ks_wlan_set_rx_gain(struct net_device *dev,
-			       struct iw_request_info *info, __u32 *uwrq,
+			       struct iw_request_info *info,
-			       char *extra)
+			       union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	if (*uwrq > 0xFF)
+	if (uwrq->mode > 0xFF)
 		return -EINVAL;
-	priv->gain.rx_gain = (u8)*uwrq;
+	priv->gain.rx_gain = (u8)uwrq->mode;
 	priv->gain.rx_mode = (priv->gain.rx_gain < 0xFF) ? 1 : 0;
 	hostif_sme_enqueue(priv, SME_SET_GAIN);
 	return 0;
 }
 static int ks_wlan_get_rx_gain(struct net_device *dev,
-			       struct iw_request_info *info, __u32 *uwrq,
+			       struct iw_request_info *info,
-			       char *extra)
+			       union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
 	if (priv->sleep_mode == SLP_SLEEP)
 		return -EPERM;
 	/* for SLEEP MODE */
-	*uwrq = priv->gain.rx_gain;
+	uwrq->mode = priv->gain.rx_gain;
 	hostif_sme_enqueue(priv, SME_GET_GAIN);
 	return 0;
 }
 static int ks_wlan_get_eeprom_cksum(struct net_device *dev,
-				    struct iw_request_info *info, __u32 *uwrq,
+				    struct iw_request_info *info,
-				    char *extra)
+				    union iwreq_data *uwrq, char *extra)
 {
 	struct ks_wlan_private *priv = netdev_priv(dev);
-	*uwrq = priv->eeprom_checksum;
+	uwrq->mode = priv->eeprom_checksum;
 	return 0;
 }
 /* get host command history */
 static int ks_wlan_hostt(struct net_device *dev, struct iw_request_info *info,
-			 __u32 *uwrq, char *extra)
+			 union iwreq_data *uwrq, char *extra)
 {
 	int i, event;
 	struct ks_wlan_private *priv = netdev_priv(dev);
 /* private_handler */
 static const iw_handler ks_wlan_private_handler[] = {
-	(iw_handler)NULL,			/* 0 */
+	NULL,				/* 0 */
-	(iw_handler)NULL,			/* 1, KS_WLAN_GET_DRIVER_VERSION */
+	NULL,				/* 1, KS_WLAN_GET_DRIVER_VERSION */
-	(iw_handler)NULL,			/* 2 */
+	NULL,				/* 2 */
-	(iw_handler)ks_wlan_get_firmware_version,/* 3 KS_WLAN_GET_FIRM_VERSION */
+	ks_wlan_get_firmware_version,	/* 3 KS_WLAN_GET_FIRM_VERSION */
-	(iw_handler)ks_wlan_set_wps_enable,	/* 4 KS_WLAN_SET_WPS_ENABLE */
+	ks_wlan_set_wps_enable,		/* 4 KS_WLAN_SET_WPS_ENABLE */
-	(iw_handler)ks_wlan_get_wps_enable,	/* 5 KS_WLAN_GET_WPS_ENABLE */
+	ks_wlan_get_wps_enable,		/* 5 KS_WLAN_GET_WPS_ENABLE */
-	(iw_handler)ks_wlan_set_wps_probe_req,	/* 6 KS_WLAN_SET_WPS_PROBE_REQ */
+	ks_wlan_set_wps_probe_req,	/* 6 KS_WLAN_SET_WPS_PROBE_REQ */
-	(iw_handler)ks_wlan_get_eeprom_cksum,	/* 7 KS_WLAN_GET_CONNECT */
+	ks_wlan_get_eeprom_cksum,	/* 7 KS_WLAN_GET_CONNECT */
-	(iw_handler)ks_wlan_set_preamble,	/* 8 KS_WLAN_SET_PREAMBLE */
+	ks_wlan_set_preamble,		/* 8 KS_WLAN_SET_PREAMBLE */
-	(iw_handler)ks_wlan_get_preamble,	/* 9 KS_WLAN_GET_PREAMBLE */
+	ks_wlan_get_preamble,		/* 9 KS_WLAN_GET_PREAMBLE */
-	(iw_handler)ks_wlan_set_power_mgmt,	/* 10 KS_WLAN_SET_POWER_SAVE */
+	ks_wlan_set_power_mgmt,		/* 10 KS_WLAN_SET_POWER_SAVE */
-	(iw_handler)ks_wlan_get_power_mgmt,	/* 11 KS_WLAN_GET_POWER_SAVE */
+	ks_wlan_get_power_mgmt,		/* 11 KS_WLAN_GET_POWER_SAVE */
-	(iw_handler)ks_wlan_set_scan_type,	/* 12 KS_WLAN_SET_SCAN_TYPE */
+	ks_wlan_set_scan_type,		/* 12 KS_WLAN_SET_SCAN_TYPE */
-	(iw_handler)ks_wlan_get_scan_type,	/* 13 KS_WLAN_GET_SCAN_TYPE */
+	ks_wlan_get_scan_type,		/* 13 KS_WLAN_GET_SCAN_TYPE */
-	(iw_handler)ks_wlan_set_rx_gain,	/* 14 KS_WLAN_SET_RX_GAIN */
+	ks_wlan_set_rx_gain,		/* 14 KS_WLAN_SET_RX_GAIN */
-	(iw_handler)ks_wlan_get_rx_gain,	/* 15 KS_WLAN_GET_RX_GAIN */
+	ks_wlan_get_rx_gain,		/* 15 KS_WLAN_GET_RX_GAIN */
-	(iw_handler)ks_wlan_hostt,		/* 16 KS_WLAN_HOSTT */
+	ks_wlan_hostt,			/* 16 KS_WLAN_HOSTT */
-	(iw_handler)NULL,			/* 17 */
+	NULL,				/* 17 */
-	(iw_handler)ks_wlan_set_beacon_lost,	/* 18 KS_WLAN_SET_BECAN_LOST */
+	ks_wlan_set_beacon_lost,	/* 18 KS_WLAN_SET_BECAN_LOST */
-	(iw_handler)ks_wlan_get_beacon_lost,	/* 19 KS_WLAN_GET_BECAN_LOST */
+	ks_wlan_get_beacon_lost,	/* 19 KS_WLAN_GET_BECAN_LOST */
-	(iw_handler)ks_wlan_set_tx_gain,	/* 20 KS_WLAN_SET_TX_GAIN */
+	ks_wlan_set_tx_gain,		/* 20 KS_WLAN_SET_TX_GAIN */
-	(iw_handler)ks_wlan_get_tx_gain,	/* 21 KS_WLAN_GET_TX_GAIN */
+	ks_wlan_get_tx_gain,		/* 21 KS_WLAN_GET_TX_GAIN */
-	(iw_handler)ks_wlan_set_phy_type,	/* 22 KS_WLAN_SET_PHY_TYPE */
+	ks_wlan_set_phy_type,		/* 22 KS_WLAN_SET_PHY_TYPE */
-	(iw_handler)ks_wlan_get_phy_type,	/* 23 KS_WLAN_GET_PHY_TYPE */
+	ks_wlan_get_phy_type,		/* 23 KS_WLAN_GET_PHY_TYPE */
-	(iw_handler)ks_wlan_set_cts_mode,	/* 24 KS_WLAN_SET_CTS_MODE */
+	ks_wlan_set_cts_mode,		/* 24 KS_WLAN_SET_CTS_MODE */
-	(iw_handler)ks_wlan_get_cts_mode,	/* 25 KS_WLAN_GET_CTS_MODE */
+	ks_wlan_get_cts_mode,		/* 25 KS_WLAN_GET_CTS_MODE */
-	(iw_handler)NULL,			/* 26 */
+	NULL,				/* 26 */
-	(iw_handler)NULL,			/* 27 */
+	NULL,				/* 27 */
-	(iw_handler)ks_wlan_set_sleep_mode,	/* 28 KS_WLAN_SET_SLEEP_MODE */
+	ks_wlan_set_sleep_mode,		/* 28 KS_WLAN_SET_SLEEP_MODE */
-	(iw_handler)ks_wlan_get_sleep_mode,	/* 29 KS_WLAN_GET_SLEEP_MODE */
+	ks_wlan_get_sleep_mode,		/* 29 KS_WLAN_GET_SLEEP_MODE */
-	(iw_handler)NULL,			/* 30 */
+	NULL,				/* 30 */
-	(iw_handler)NULL,			/* 31 */
+	NULL,				/* 31 */
 };
 static const struct iw_handler_def ks_wlan_handler_def = {
 	switch (cmd) {
 	case SIOCIWFIRSTPRIV + 20:	/* KS_WLAN_SET_STOP_REQ */
-		ret = ks_wlan_set_stop_request(dev, NULL, &wrq->u.mode, NULL);
+		ret = ks_wlan_set_stop_request(dev, NULL, &wrq->u, NULL);
 		break;
 		// All other calls are currently unsupported
 	default:

drivers/staging/most/dim2/dim2.c+2−2

@@ -161,7 +161,7 @@ static int try_start_dim_transfer(struct hdm_channel *hdm_ch) · 160 unmodified lines
161	struct list_head *head = &hdm_ch->pending_list;	161	struct list_head *head = &hdm_ch->pending_list;
162	struct mbo *mbo;	162	struct mbo *mbo;
163	unsigned long flags;	163	unsigned long flags;
164	struct dim_ch_state_t st;	164	struct dim_ch_state st;
165		165
166	BUG_ON(!hdm_ch);	166	BUG_ON(!hdm_ch);
167	BUG_ON(!hdm_ch->is_initialized);	167	BUG_ON(!hdm_ch->is_initialized);
@@ -259,7 +259,7 @@ static void retrieve_netinfo(struct dim2_hdm dev, struct mbo mbo) · 91 unmodified lines
259	static void service_done_flag(struct dim2_hdm *dev, int ch_idx)	259	static void service_done_flag(struct dim2_hdm *dev, int ch_idx)
260	{	260	{
261	struct hdm_channel *hdm_ch = dev->hch + ch_idx;	261	struct hdm_channel *hdm_ch = dev->hch + ch_idx;
262	struct dim_ch_state_t st;	262	struct dim_ch_state st;
263	struct list_head *head;	263	struct list_head *head;
264	struct mbo *mbo;	264	struct mbo *mbo;
265	int done_buffers;	265	int done_buffers;

drivers/staging/most/dim2/hal.c+2−2

@@ -943,8 +943,8 @@ u8 dim_service_channel(struct dim_channel *ch) · 942 unmodified lines
943	return channel_service(ch);	943	return channel_service(ch);
944	}	944	}
945		945
946	struct dim_ch_state_t dim_get_channel_state(struct dim_channel ch,	946	struct dim_ch_state dim_get_channel_state(struct dim_channel ch,
947	struct dim_ch_state_t *state_ptr)	947	struct dim_ch_state *state_ptr)
948	{	948	{
949	if (!ch \|\| !state_ptr)	949	if (!ch \|\| !state_ptr)
950	return NULL;	950	return NULL;

drivers/staging/most/dim2/hal.h+3−3

@@ -27,7 +27,7 @@ enum mlb_clk_speed { · 26 unmodified lines
27	CLK_8192FS = 7,	27	CLK_8192FS = 7,
28	};	28	};
29		29
30	struct dim_ch_state_t {	30	struct dim_ch_state {
31	bool ready; /* Shows readiness to enqueue next buffer */	31	bool ready; /* Shows readiness to enqueue next buffer */
32	u16 done_buffers; /* Number of completed buffers */	32	u16 done_buffers; /* Number of completed buffers */
33	};	33	};
@@ -87,8 +87,8 @@ void dim_service_ahb_int_irq(struct dim_channel const channels); · 53 unmodified lines
87		87
88	u8 dim_service_channel(struct dim_channel *ch);	88	u8 dim_service_channel(struct dim_channel *ch);
89		89
90	struct dim_ch_state_t dim_get_channel_state(struct dim_channel ch,	90	struct dim_ch_state dim_get_channel_state(struct dim_channel ch,
91	struct dim_ch_state_t *state_ptr);	91	struct dim_ch_state *state_ptr);
92		92
93	u16 dim_dbr_space(struct dim_channel *ch);	93	u16 dim_dbr_space(struct dim_channel *ch);
94		94

drivers/staging/most/i2c/i2c.c+2−2

@@ -284,7 +284,7 @@ static irqreturn_t most_irq_handler(int irq, void *_dev) · 283 unmodified lines
284	*	284	*
285	* Register the i2c client device as a MOST interface	285	* Register the i2c client device as a MOST interface
286	*/	286	*/
287	static int i2c_probe(struct i2c_client client, const struct i2c_device_id id)	287	static int i2c_probe(struct i2c_client *client)
288	{	288	{
289	struct hdm_i2c *dev;	289	struct hdm_i2c *dev;
290	int ret, i;	290	int ret, i;
@@ -359,7 +359,7 @@ static struct i2c_driver i2c_driver = { · 68 unmodified lines
359	.driver = {	359	.driver = {
360	.name = "hdm_i2c",	360	.name = "hdm_i2c",
361	},	361	},
362	.probe = i2c_probe,	362	.probe_new = i2c_probe,
363	.remove = i2c_remove,	363	.remove = i2c_remove,
364	.id_table = i2c_id,	364	.id_table = i2c_id,
365	};	365	};

drivers/staging/octeon/ethernet-tx.c+0−2

 {
 	int skb_to_free;
 	int qos, queues_per_port;
-	int total_freed = 0;
 	int total_remaining = 0;
 	unsigned long flags;
 	struct octeon_ethernet *priv = netdev_priv(dev);
 						       MAX_SKB_TO_FREE);
 		skb_to_free = cvm_oct_adjust_skb_to_free(skb_to_free,
 							 priv->fau + qos * 4);
-		total_freed += skb_to_free;
 		if (skb_to_free > 0) {
 			struct sk_buff *to_free_list = NULL;

drivers/staging/octeon/octeon-stubs.h+1−1

@@ -1212,7 +1212,7 @@ static inline void *cvmx_phys_to_ptr(uint64_t physical_address) · 1211 unmodified lines
1212	return (void *)(uintptr_t)(physical_address);	1212	return (void *)(uintptr_t)(physical_address);
1213	}	1213	}
1214		1214
1215	static inline uint64_t cvmx_ptr_to_phys(void *ptr)	1215	static inline phys_addr_t cvmx_ptr_to_phys(void *ptr)
1216	{	1216	{
1217	return (unsigned long)ptr;	1217	return (unsigned long)ptr;
1218	}	1218	}

drivers/staging/olpc_dcon/olpc_dcon.c+2−2

@@ -579,7 +579,7 @@ static int dcon_detect(struct i2c_client client, struct i2c_board_info info) · 578 unmodified lines
579	return 0;	579	return 0;
580	}	580	}
581		581
582	static int dcon_probe(struct i2c_client client, const struct i2c_device_id id)	582	static int dcon_probe(struct i2c_client *client)
583	{	583	{
584	struct dcon_priv *dcon;	584	struct dcon_priv *dcon;
585	int rc, i, j;	585	int rc, i, j;
@@ -779,7 +779,7 @@ static struct i2c_driver dcon_driver = { · 193 unmodified lines
779	},	779	},
780	.class = I2C_CLASS_DDC \| I2C_CLASS_HWMON,	780	.class = I2C_CLASS_DDC \| I2C_CLASS_HWMON,
781	.id_table = dcon_idtable,	781	.id_table = dcon_idtable,
782	.probe = dcon_probe,	782	.probe_new = dcon_probe,
783	.remove = dcon_remove,	783	.remove = dcon_remove,
784	.detect = dcon_detect,	784	.detect = dcon_detect,
785	.address_list = normal_i2c,	785	.address_list = normal_i2c,

drivers/staging/r8188eu/core/rtw_ap.c+2−5

 	return beacon_updated;
 }
-int rtw_sta_flush(struct adapter *padapter)
+void rtw_sta_flush(struct adapter *padapter)
 {
 	struct list_head *phead, *plist;
-	int ret = 0;
 	struct sta_info *psta = NULL;
 	struct sta_priv *pstapriv = &padapter->stapriv;
 	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 	u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 	if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
-		return ret;
+		return;
 	spin_lock_bh(&pstapriv->asoc_list_lock);
 	phead = &pstapriv->asoc_list;
 	issue_deauth(padapter, bc_addr, WLAN_REASON_DEAUTH_LEAVING);
 	associated_clients_update(padapter, true);
-	return ret;
 }
 /* called > TSR LEVEL for USB or SDIO Interface*/

drivers/staging/r8188eu/core/rtw_br_ext.c+62−64

 static unsigned char *__nat25_find_pppoe_tag(struct pppoe_hdr *ph, unsigned short type)
 {
 	unsigned char *cur_ptr, *start_ptr;
-	unsigned short tagLen, tagType;
+	unsigned short tag_len, tag_type;
 	start_ptr = (unsigned char *)ph->tag;
 	cur_ptr = (unsigned char *)ph->tag;
 	while ((cur_ptr - start_ptr) < ntohs(ph->length)) {
 		/*  prevent un-alignment access */
-		tagType = (unsigned short)((cur_ptr[0] << 8) + cur_ptr[1]);
+		tag_type = (unsigned short)((cur_ptr[0] << 8) + cur_ptr[1]);
-		tagLen  = (unsigned short)((cur_ptr[2] << 8) + cur_ptr[3]);
+		tag_len  = (unsigned short)((cur_ptr[2] << 8) + cur_ptr[3]);
-		if (tagType == type)
+		if (tag_type == type)
 			return cur_ptr;
-		cur_ptr = cur_ptr + TAG_HDR_LEN + tagLen;
+		cur_ptr = cur_ptr + TAG_HDR_LEN + tag_len;
 	}
 	return NULL;
 }
 	return 0;
 }
-static void __nat25_generate_ipv4_network_addr(unsigned char *networkAddr,
+static void __nat25_generate_ipv4_network_addr(unsigned char *addr,
-				unsigned int *ipAddr)
+				unsigned int *ip_addr)
 {
-	memset(networkAddr, 0, MAX_NETWORK_ADDR_LEN);
+	memset(addr, 0, MAX_NETWORK_ADDR_LEN);
-	networkAddr[0] = NAT25_IPV4;
+	addr[0] = NAT25_IPV4;
-	memcpy(networkAddr + 7, (unsigned char *)ipAddr, 4);
+	memcpy(addr + 7, (unsigned char *)ip_addr, 4);
 }
-static void __nat25_generate_pppoe_network_addr(unsigned char *networkAddr,
+static void __nat25_generate_pppoe_network_addr(unsigned char *addr,
 				unsigned char *ac_mac, __be16 *sid)
 {
-	memset(networkAddr, 0, MAX_NETWORK_ADDR_LEN);
+	memset(addr, 0, MAX_NETWORK_ADDR_LEN);
-	networkAddr[0] = NAT25_PPPOE;
+	addr[0] = NAT25_PPPOE;
-	memcpy(networkAddr + 1, (unsigned char *)sid, 2);
+	memcpy(addr + 1, (unsigned char *)sid, 2);
-	memcpy(networkAddr + 3, (unsigned char *)ac_mac, 6);
+	memcpy(addr + 3, (unsigned char *)ac_mac, 6);
 }
-static  void __nat25_generate_ipv6_network_addr(unsigned char *networkAddr,
+static  void __nat25_generate_ipv6_network_addr(unsigned char *addr,
-				unsigned int *ipAddr)
+				unsigned int *ip_addr)
 {
-	memset(networkAddr, 0, MAX_NETWORK_ADDR_LEN);
+	memset(addr, 0, MAX_NETWORK_ADDR_LEN);
-	networkAddr[0] = NAT25_IPV6;
+	addr[0] = NAT25_IPV6;
-	memcpy(networkAddr + 1, (unsigned char *)ipAddr, 16);
+	memcpy(addr + 1, (unsigned char *)ip_addr, 16);
 }
 static unsigned char *scan_tlv(unsigned char *data, int len, unsigned char tag, unsigned char len8b)
 	return 0;
 }
-static int __nat25_network_hash(unsigned char *networkAddr)
+static int __nat25_network_hash(unsigned char *addr)
 {
-	if (networkAddr[0] == NAT25_IPV4) {
+	if (addr[0] == NAT25_IPV4) {
 		unsigned long x;
-		x = networkAddr[7] ^ networkAddr[8] ^ networkAddr[9] ^ networkAddr[10];
+		x = addr[7] ^ addr[8] ^ addr[9] ^ addr[10];
 		return x & (NAT25_HASH_SIZE - 1);
-	} else if (networkAddr[0] == NAT25_IPX) {
+	} else if (addr[0] == NAT25_IPX) {
 		unsigned long x;
-		x = networkAddr[1] ^ networkAddr[2] ^ networkAddr[3] ^ networkAddr[4] ^ networkAddr[5] ^
+		x = addr[1] ^ addr[2] ^ addr[3] ^ addr[4] ^ addr[5] ^
-			networkAddr[6] ^ networkAddr[7] ^ networkAddr[8] ^ networkAddr[9] ^ networkAddr[10];
+		    addr[6] ^ addr[7] ^ addr[8] ^ addr[9] ^ addr[10];
 		return x & (NAT25_HASH_SIZE - 1);
-	} else if (networkAddr[0] == NAT25_APPLE) {
+	} else if (addr[0] == NAT25_APPLE) {
 		unsigned long x;
-		x = networkAddr[1] ^ networkAddr[2] ^ networkAddr[3];
+		x = addr[1] ^ addr[2] ^ addr[3];
 		return x & (NAT25_HASH_SIZE - 1);
-	} else if (networkAddr[0] == NAT25_PPPOE) {
+	} else if (addr[0] == NAT25_PPPOE) {
 		unsigned long x;
-		x = networkAddr[0] ^ networkAddr[1] ^ networkAddr[2] ^ networkAddr[3] ^ networkAddr[4] ^ networkAddr[5] ^ networkAddr[6] ^ networkAddr[7] ^ networkAddr[8];
+		x = addr[0] ^ addr[1] ^ addr[2] ^ addr[3] ^ addr[4] ^
+		    addr[5] ^ addr[6] ^ addr[7] ^ addr[8];
 		return x & (NAT25_HASH_SIZE - 1);
-	} else if (networkAddr[0] == NAT25_IPV6) {
+	} else if (addr[0] == NAT25_IPV6) {
 		unsigned long x;
-		x = networkAddr[1] ^ networkAddr[2] ^ networkAddr[3] ^ networkAddr[4] ^ networkAddr[5] ^
+		x = addr[1] ^ addr[2] ^ addr[3] ^ addr[4] ^ addr[5] ^ addr[6] ^
-			networkAddr[6] ^ networkAddr[7] ^ networkAddr[8] ^ networkAddr[9] ^ networkAddr[10] ^
+		    addr[7] ^ addr[8] ^ addr[9] ^ addr[10] ^ addr[11] ^ addr[12] ^
-			networkAddr[11] ^ networkAddr[12] ^ networkAddr[13] ^ networkAddr[14] ^ networkAddr[15] ^
+		    addr[13] ^ addr[14] ^ addr[15] ^ addr[16];
-			networkAddr[16];
 		return x & (NAT25_HASH_SIZE - 1);
 	} else {
 		int i;
 		for (i = 0; i < MAX_NETWORK_ADDR_LEN; i++)
-			x ^= networkAddr[i];
+			x ^= addr[i];
 		return x & (NAT25_HASH_SIZE - 1);
 	}
 }
 static void __nat25_db_network_insert(struct adapter *priv,
-				unsigned char *macAddr, unsigned char *networkAddr)
+				unsigned char *mac_addr, unsigned char *addr)
 {
 	struct nat25_network_db_entry *db;
 	int hash;
 	spin_lock_bh(&priv->br_ext_lock);
-	hash = __nat25_network_hash(networkAddr);
+	hash = __nat25_network_hash(addr);
 	db = priv->nethash[hash];
 	while (db) {
-		if (!memcmp(db->networkAddr, networkAddr, MAX_NETWORK_ADDR_LEN)) {
+		if (!memcmp(db->networkAddr, addr, MAX_NETWORK_ADDR_LEN)) {
-			memcpy(db->macAddr, macAddr, ETH_ALEN);
+			memcpy(db->macAddr, mac_addr, ETH_ALEN);
 			db->ageing_timer = jiffies;
 			spin_unlock_bh(&priv->br_ext_lock);
 			return;
 		spin_unlock_bh(&priv->br_ext_lock);
 		return;
 	}
-	memcpy(db->networkAddr, networkAddr, MAX_NETWORK_ADDR_LEN);
+	memcpy(db->networkAddr, addr, MAX_NETWORK_ADDR_LEN);
-	memcpy(db->macAddr, macAddr, ETH_ALEN);
+	memcpy(db->macAddr, mac_addr, ETH_ALEN);
 	atomic_set(&db->use_count, 1);
 	db->ageing_timer = jiffies;
 int nat25_db_handle(struct adapter *priv, struct sk_buff *skb, int method)
 {
 	unsigned short protocol;
-	unsigned char networkAddr[MAX_NETWORK_ADDR_LEN];
+	unsigned char addr[MAX_NETWORK_ADDR_LEN];
 	unsigned int tmp;
 	if (!skb)
 			if (iph->saddr == 0)
 				return 0;
 			tmp = be32_to_cpu(iph->saddr);
-			__nat25_generate_ipv4_network_addr(networkAddr, &tmp);
+			__nat25_generate_ipv4_network_addr(addr, &tmp);
 			/* record source IP address and , source mac address into db */
-			__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
+			__nat25_db_network_insert(priv, skb->data + ETH_ALEN, addr);
 			return 0;
 		default:
 			return -1;
 			memcpy(arp_ptr, GET_MY_HWADDR(priv), ETH_ALEN);
 			arp_ptr += arp->ar_hln;
 			sender = (unsigned int *)arp_ptr;
-			__nat25_generate_ipv4_network_addr(networkAddr, sender);
+			__nat25_generate_ipv4_network_addr(addr, sender);
-			__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
+			__nat25_db_network_insert(priv, skb->data + ETH_ALEN, addr);
 			return 0;
 		default:
 			return -1;
 					return -1;
 				}
 			} else {	/*  session phase */
-				__nat25_generate_pppoe_network_addr(networkAddr, skb->data, &ph->sid);
+				__nat25_generate_pppoe_network_addr(addr, skb->data, &ph->sid);
-				__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
+				__nat25_db_network_insert(priv, skb->data + ETH_ALEN, addr);
 				if (!priv->ethBrExtInfo.addPPPoETag &&
 				    priv->pppoe_connection_in_progress &&
 			return -1;
 		case NAT25_INSERT:
 			if (memcmp(&iph->saddr, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0", 16)) {
-				__nat25_generate_ipv6_network_addr(networkAddr, (unsigned int *)&iph->saddr);
+				__nat25_generate_ipv6_network_addr(addr, (unsigned int *)&iph->saddr);
-				__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
+				__nat25_db_network_insert(priv, skb->data + ETH_ALEN, addr);
 				if (iph->nexthdr == IPPROTO_ICMPV6 &&
 						skb->len > (ETH_HLEN +  sizeof(*iph) + 4)) {
 	if (!priv->ethBrExtInfo.dhcp_bcst_disable) {
 		__be16 protocol = *((__be16 *)(skb->data + 2 * ETH_ALEN));
-		if (protocol == __constant_htons(ETH_P_IP)) { /*  IP */
+		if (protocol == htons(ETH_P_IP)) { /*  IP */
 			struct iphdr *iph = (struct iphdr *)(skb->data + ETH_HLEN);
 			if (iph->protocol == IPPROTO_UDP) { /*  UDP */
-				struct udphdr *udph = (struct udphdr *)((size_t)iph + (iph->ihl << 2));
+				struct udphdr *udph = (void *)iph + (iph->ihl << 2);
-				if ((udph->source == __constant_htons(CLIENT_PORT)) &&
+				if ((udph->source == htons(CLIENT_PORT)) &&
-				    (udph->dest == __constant_htons(SERVER_PORT))) { /*  DHCP request */
+				    (udph->dest == htons(SERVER_PORT))) { /*  DHCP request */
-					struct dhcpMessage *dhcph =
+					struct dhcpMessage *dhcph = (void *)udph + sizeof(struct udphdr);
-						(struct dhcpMessage *)((size_t)udph + sizeof(struct udphdr));
+					u32 cookie = be32_to_cpu(dhcph->cookie);
-					u32 cookie = be32_to_cpu((__be32)dhcph->cookie);
 					if (cookie == DHCP_MAGIC) { /*  match magic word */
 						if (!(dhcph->flags & htons(BROADCAST_FLAG))) {
 	}
 }
-void *scdb_findEntry(struct adapter *priv, unsigned char *ipAddr)
+void *scdb_findEntry(struct adapter *priv, unsigned char *ip_addr)
 {
-	unsigned char networkAddr[MAX_NETWORK_ADDR_LEN];
+	unsigned char addr[MAX_NETWORK_ADDR_LEN];
 	struct nat25_network_db_entry *db;
 	int hash;
-	__nat25_generate_ipv4_network_addr(networkAddr, (unsigned int *)ipAddr);
+	__nat25_generate_ipv4_network_addr(addr, (unsigned int *)ip_addr);
-	hash = __nat25_network_hash(networkAddr);
+	hash = __nat25_network_hash(addr);
 	db = priv->nethash[hash];
 	while (db) {
-		if (!memcmp(db->networkAddr, networkAddr, MAX_NETWORK_ADDR_LEN)) {
+		if (!memcmp(db->networkAddr, addr, MAX_NETWORK_ADDR_LEN))
 			return (void *)db;
-		}
 		db = db->next_hash;
 	}

drivers/staging/r8188eu/core/rtw_cmd.c+14−20

 	return _SUCCESS;
 }
-u32	rtw_init_cmd_priv(struct cmd_priv *pcmdpriv)
+int rtw_init_cmd_priv(struct cmd_priv *pcmdpriv)
 {
 	init_completion(&pcmdpriv->enqueue_cmd);
 	/* sema_init(&(pcmdpriv->cmd_done_sema), 0); */
 					      GFP_KERNEL);
 	if (!pcmdpriv->cmd_allocated_buf)
-		return _FAIL;
+		return -ENOMEM;
 	pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf  +  CMDBUFF_ALIGN_SZ - ((size_t)(pcmdpriv->cmd_allocated_buf) & (CMDBUFF_ALIGN_SZ - 1));
 	if (!pcmdpriv->rsp_allocated_buf) {
 		kfree(pcmdpriv->cmd_allocated_buf);
-		return _FAIL;
+		return -ENOMEM;
 	}
 	pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf  +  4 - ((size_t)(pcmdpriv->rsp_allocated_buf) & 3);
 	pcmdpriv->cmd_done_cnt = 0;
 	pcmdpriv->rsp_cnt = 0;
-	return _SUCCESS;
+	return 0;
 }
-u32 rtw_init_evt_priv(struct evt_priv *pevtpriv)
+int rtw_init_evt_priv(struct evt_priv *pevtpriv)
 {
-	u32 res = _SUCCESS;
 	/* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
 	atomic_set(&pevtpriv->event_seq, 0);
 	pevtpriv->c2h_wk_alive = false;
 	pevtpriv->c2h_queue = rtw_cbuf_alloc(C2H_QUEUE_MAX_LEN + 1);
 	if (!pevtpriv->c2h_queue)
-		res = _FAIL;
+		return -ENOMEM;
-	return res;
+	return 0;
 }
 void rtw_free_cmd_priv(struct	cmd_priv *pcmdpriv)
 	return res;
 }
-u8 rtw_setdatarate_cmd(struct adapter *padapter, u8 *rateset)
+int rtw_setdatarate_cmd(struct adapter *padapter, u8 *rateset)
 {
 	struct cmd_obj *ph2c;
 	struct setdatarate_parm *pbsetdataratepara;
 	struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
-	u8	res = _SUCCESS;
 	ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC);
-	if (!ph2c) {
+	if (!ph2c)
-		res = _FAIL;
+		return -ENOMEM;
-		goto exit;
-	}
 	pbsetdataratepara = kzalloc(sizeof(*pbsetdataratepara), GFP_ATOMIC);
 	if (!pbsetdataratepara) {
 		kfree(ph2c);
-		res = _FAIL;
+		return -ENOMEM;
-		goto exit;
 	}
 	init_h2fwcmd_w_parm_no_rsp(ph2c, pbsetdataratepara, GEN_CMD_CODE(_SetDataRate));
 	pbsetdataratepara->mac_id = 5;
 	memcpy(pbsetdataratepara->datarates, rateset, NumRates);
-	res = rtw_enqueue_cmd(pcmdpriv, ph2c);
+	if (rtw_enqueue_cmd(pcmdpriv, ph2c) == _FAIL)
-exit:
+		return -EPERM;
-	return res;
+	return 0;
 }
 void rtw_getbbrfreg_cmdrsp_callback(struct adapter *padapter,  struct cmd_obj *pcmd)

drivers/staging/r8188eu/core/rtw_ioctl_set.c+2−4

 		if ((*pold_state == Ndis802_11Infrastructure) || (*pold_state == Ndis802_11IBSS)) {
 			if (check_fwstate(pmlmepriv, _FW_LINKED))
-				rtw_indicate_disconnect(padapter); /* will clr Linked_state; before this function, we must have chked whether  issue dis-assoc_cmd or not */
+				rtw_indicate_disconnect(padapter); /* will clr Linked_state; before this function, we must have checked whether issue dis-assoc_cmd or not */
 	       }
 		*pold_state = networktype;
 	return true;
 }
-u8 rtw_set_802_11_disassociate(struct adapter *padapter)
+void rtw_set_802_11_disassociate(struct adapter *padapter)
 {
 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 	}
 	spin_unlock_bh(&pmlmepriv->lock);
-	return true;
 }
 u8 rtw_set_802_11_bssid_list_scan(struct adapter *padapter, struct ndis_802_11_ssid *pssid, int ssid_max_num)

drivers/staging/r8188eu/core/rtw_led.c+19−60

 	pLed->BlinkTimes = 0; /*  Number of times to toggle led state for blinking. */
-	pLed->bLedLinkBlinkInProgress = false;
 	pLed->bLedScanBlinkInProgress = false;
 }
-static void SwLedOn(struct adapter *padapter, struct led_priv *pLed)
+static void SwLedOn(struct led_priv *pLed)
 {
-	u8	LedCfg;
+	struct adapter *padapter = container_of(pLed, struct adapter, ledpriv);
-	int res;
 	if (padapter->bDriverStopped)
 		return;
-	res = rtw_read8(padapter, REG_LEDCFG2, &LedCfg);
+	if (rtw_write8(padapter, REG_LEDCFG2, BIT(5)) != _SUCCESS)
-	if (res)
 		return;
-	rtw_write8(padapter, REG_LEDCFG2, (LedCfg & 0xf0) | BIT(5) | BIT(6)); /*  SW control led0 on. */
 	pLed->bLedOn = true;
 }
-static void SwLedOff(struct adapter *padapter, struct led_priv *pLed)
+static void SwLedOff(struct led_priv *pLed)
 {
-	u8	LedCfg;
+	struct adapter *padapter = container_of(pLed, struct adapter, ledpriv);
-	int res;
 	if (padapter->bDriverStopped)
-		goto exit;
+		return;
-	res = rtw_read8(padapter, REG_LEDCFG2, &LedCfg);/* 0x4E */
-	if (res)
-		goto exit;
-	LedCfg &= 0x90; /*  Set to software control. */
+	if (rtw_write8(padapter, REG_LEDCFG2, BIT(5) | BIT(3)) != _SUCCESS)
-	rtw_write8(padapter, REG_LEDCFG2, (LedCfg | BIT(3)));
+		return;
-	res = rtw_read8(padapter, REG_MAC_PINMUX_CFG, &LedCfg);
-	if (res)
-		goto exit;
-	LedCfg &= 0xFE;
-	rtw_write8(padapter, REG_MAC_PINMUX_CFG, LedCfg);
-exit:
 	pLed->bLedOn = false;
 }
 {
 	struct delayed_work *dwork = to_delayed_work(work);
 	struct led_priv *pLed = container_of(dwork, struct led_priv, blink_work);
-	struct adapter *padapter = pLed->padapter;
+	struct adapter *padapter = container_of(pLed, struct adapter, ledpriv);
 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 	if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
-		SwLedOff(padapter, pLed);
+		SwLedOff(pLed);
 		ResetLedStatus(pLed);
 		return;
 	}
 	if (pLed->bLedOn)
-		SwLedOff(padapter, pLed);
+		SwLedOff(pLed);
 	else
-		SwLedOn(padapter, pLed);
+		SwLedOn(pLed);
 	switch (pLed->CurrLedState) {
 	case LED_BLINK_SLOWLY:
 		schedule_delayed_work(&pLed->blink_work, LED_BLINK_LINK_INTVL);
 		break;
 	case LED_BLINK_SCAN:
-		pLed->BlinkTimes--;
-		if (pLed->BlinkTimes == 0) {
-			if (check_fwstate(pmlmepriv, _FW_LINKED)) {
-				pLed->bLedLinkBlinkInProgress = true;
-				pLed->CurrLedState = LED_BLINK_NORMAL;
-				schedule_delayed_work(&pLed->blink_work, LED_BLINK_LINK_INTVL);
-			} else {
-				pLed->CurrLedState = LED_BLINK_SLOWLY;
-				schedule_delayed_work(&pLed->blink_work, LED_BLINK_NO_LINK_INTVL);
-			}
-			pLed->bLedScanBlinkInProgress = false;
-		} else {
-			schedule_delayed_work(&pLed->blink_work, LED_BLINK_SCAN_INTVL);
-		}
-		break;
 	case LED_BLINK_TXRX:
 		pLed->BlinkTimes--;
 		if (pLed->BlinkTimes == 0) {
 			if (check_fwstate(pmlmepriv, _FW_LINKED)) {
-				pLed->bLedLinkBlinkInProgress = true;
 				pLed->CurrLedState = LED_BLINK_NORMAL;
 				schedule_delayed_work(&pLed->blink_work, LED_BLINK_LINK_INTVL);
 			} else {
 				schedule_delayed_work(&pLed->blink_work, LED_BLINK_NO_LINK_INTVL);
 			}
 			pLed->bLedBlinkInProgress = false;
+			pLed->bLedScanBlinkInProgress = false;
 		} else {
-			schedule_delayed_work(&pLed->blink_work, LED_BLINK_FASTER_INTVL);
+			schedule_delayed_work(&pLed->blink_work,
+					      pLed->CurrLedState == LED_BLINK_SCAN ?
+					      LED_BLINK_SCAN_INTVL : LED_BLINK_FASTER_INTVL);
 		}
 		break;
 	case LED_BLINK_WPS:
 		break;
 	case LED_BLINK_WPS_STOP:	/* WPS success */
 		if (!pLed->bLedOn) {
-			pLed->bLedLinkBlinkInProgress = true;
 			pLed->CurrLedState = LED_BLINK_NORMAL;
 			schedule_delayed_work(&pLed->blink_work, LED_BLINK_LINK_INTVL);
 {
 	struct led_priv *pledpriv = &padapter->ledpriv;
-	pledpriv->padapter = padapter;
 	ResetLedStatus(pledpriv);
 	INIT_DELAYED_WORK(&pledpriv->blink_work, blink_work);
 }
 	cancel_delayed_work_sync(&ledpriv->blink_work);
 	ResetLedStatus(ledpriv);
-	SwLedOff(padapter, ledpriv);
+	SwLedOff(ledpriv);
 }
 void rtw_led_control(struct adapter *padapter, enum LED_CTL_MODE LedAction)
 	struct registry_priv *registry_par;
 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
-	if ((padapter->bSurpriseRemoved) || (padapter->bDriverStopped) ||
+	if (!padapter->hw_init_completed)
-	    (!padapter->hw_init_completed))
 		return;
 	if (!pLed->bRegUseLed)
 		cancel_delayed_work(&pLed->blink_work);
-		pLed->bLedLinkBlinkInProgress = false;
 		pLed->bLedBlinkInProgress = false;
 		pLed->CurrLedState = LED_BLINK_SLOWLY;
 		schedule_delayed_work(&pLed->blink_work, LED_BLINK_NO_LINK_INTVL);
 		break;
 	case LED_CTL_LINK:
-		if (!pLed->bLedLinkBlinkInProgress)
-			return;
 		if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
 			return;
 		cancel_delayed_work(&pLed->blink_work);
 		pLed->bLedBlinkInProgress = false;
-		pLed->bLedLinkBlinkInProgress = true;
 		pLed->CurrLedState = LED_BLINK_NORMAL;
 		schedule_delayed_work(&pLed->blink_work, LED_BLINK_LINK_INTVL);
 		cancel_delayed_work(&pLed->blink_work);
-		pLed->bLedLinkBlinkInProgress = false;
 		pLed->bLedBlinkInProgress = false;
 		pLed->bLedScanBlinkInProgress = true;
 		cancel_delayed_work(&pLed->blink_work);
-		pLed->bLedLinkBlinkInProgress = false;
 		pLed->bLedBlinkInProgress = true;
 		pLed->CurrLedState = LED_BLINK_TXRX;
 		cancel_delayed_work(&pLed->blink_work);
-		pLed->bLedLinkBlinkInProgress = false;
 		pLed->bLedBlinkInProgress = false;
 		pLed->bLedScanBlinkInProgress = false;
 		pLed->bLedWPSBlinkInProgress = true;
 	case LED_CTL_STOP_WPS:
 		cancel_delayed_work(&pLed->blink_work);
-		pLed->bLedLinkBlinkInProgress = false;
 		pLed->bLedBlinkInProgress = false;
 		pLed->bLedScanBlinkInProgress = false;
 		pLed->bLedWPSBlinkInProgress = true;
 		break;
 	case LED_CTL_POWER_OFF:
 		pLed->CurrLedState = RTW_LED_OFF;
-		pLed->bLedLinkBlinkInProgress = false;
 		pLed->bLedBlinkInProgress = false;
 		pLed->bLedWPSBlinkInProgress = false;
 		pLed->bLedScanBlinkInProgress = false;
 		cancel_delayed_work(&pLed->blink_work);
-		SwLedOff(padapter, pLed);
+		SwLedOff(pLed);
 		break;
 	default:
 		break;

drivers/staging/r8188eu/core/rtw_mlme.c+12−39

@@ -76,19 +76,6 @@ void _rtw_free_network(struct mlme_priv pmlmepriv, struct wlan_network pnetwor · 75 unmodified lines
76	spin_unlock_bh(&free_queue->lock);	76	spin_unlock_bh(&free_queue->lock);
77	}	77	}
78		78
79	void _rtw_free_network_nolock(struct mlme_priv pmlmepriv, struct wlan_network pnetwork)
80	{
81	struct __queue *free_queue = &pmlmepriv->free_bss_pool;
82
83	if (!pnetwork)
84	return;
85	if (pnetwork->fixed)
86	return;
87	list_del_init(&pnetwork->list);
88	list_add_tail(&pnetwork->list, get_list_head(free_queue));
89	pmlmepriv->num_of_scanned--;
90	}
91
92	/*	79	/*
93	return the wlan_network with the matching addr	80	return the wlan_network with the matching addr
94		81
@@ -224,7 +211,6 @@ int rtw_init_mlme_priv(struct adapter padapter)/ struct mlme_priv *pmlmepriv) · 129 unmodified lines
224	u8 *pbuf;	211	u8 *pbuf;
225	struct wlan_network *pnetwork;	212	struct wlan_network *pnetwork;
226	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;	213	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
227	int res = _SUCCESS;
228		214
229	/* We don't need to memset padapter->XXX to zero, because adapter is allocated by vzalloc(). */	215	/* We don't need to memset padapter->XXX to zero, because adapter is allocated by vzalloc(). */
230		216
@@ -245,10 +231,9 @@ int rtw_init_mlme_priv(struct adapter padapter)/ struct mlme_priv *pmlmepriv) · 14 unmodified lines
245		231
246	pbuf = vzalloc(MAX_BSS_CNT * (sizeof(struct wlan_network)));	232	pbuf = vzalloc(MAX_BSS_CNT * (sizeof(struct wlan_network)));
247		233
248	if (!pbuf) {	234	if (!pbuf)
249	res = _FAIL;	235	return -ENOMEM;
250	goto exit;	236
251	}
252	pmlmepriv->free_bss_buf = pbuf;	237	pmlmepriv->free_bss_buf = pbuf;
253		238
254	pnetwork = (struct wlan_network *)pbuf;	239	pnetwork = (struct wlan_network *)pbuf;
@@ -265,9 +250,7 @@ int rtw_init_mlme_priv(struct adapter padapter)/ struct mlme_priv *pmlmepriv) · 10 unmodified lines
265		250
266	rtw_init_mlme_timer(padapter);	251	rtw_init_mlme_timer(padapter);
267		252
268	exit:	253	return 0;
269
270	return res;
271	}	254	}
272		255
273	void rtw_free_mlme_priv(struct mlme_priv *pmlmepriv)	256	void rtw_free_mlme_priv(struct mlme_priv *pmlmepriv)
@@ -311,9 +294,15 @@ exit: · 37 unmodified lines
311	static void rtw_free_network_nolock(struct mlme_priv *pmlmepriv,	294	static void rtw_free_network_nolock(struct mlme_priv *pmlmepriv,
312	struct wlan_network *pnetwork)	295	struct wlan_network *pnetwork)
313	{	296	{
		297	struct __queue *free_queue = &pmlmepriv->free_bss_pool;
314		298
315	_rtw_free_network_nolock(pmlmepriv, pnetwork);	299	if (!pnetwork)
316		300	return;
		301	if (pnetwork->fixed)
		302	return;
		303	list_del_init(&pnetwork->list);
		304	list_add_tail(&pnetwork->list, get_list_head(free_queue));
		305	pmlmepriv->num_of_scanned--;
317	}	306	}
318		307
319	void rtw_free_network_queue(struct adapter *dev, u8 isfreeall)	308	void rtw_free_network_queue(struct adapter *dev, u8 isfreeall)
@@ -1823,22 +1812,6 @@ void rtw_update_registrypriv_dev_network(struct adapter *adapter) · 1503 unmodified lines
1823		1812
1824	pdev_network->Rssi = 0;	1813	pdev_network->Rssi = 0;
1825		1814
1826	switch (pregistrypriv->wireless_mode) {
1827	case WIRELESS_11B:
1828	pdev_network->NetworkTypeInUse = (Ndis802_11DS);
1829	break;
1830	case WIRELESS_11G:
1831	case WIRELESS_11BG:
1832	case WIRELESS_11_24N:
1833	case WIRELESS_11G_24N:
1834	case WIRELESS_11BG_24N:
1835	pdev_network->NetworkTypeInUse = (Ndis802_11OFDM24);
1836	break;
1837	default:
1838	/* TODO */
1839	break;
1840	}
1841
1842	pdev_network->Configuration.DSConfig = (pregistrypriv->channel);	1815	pdev_network->Configuration.DSConfig = (pregistrypriv->channel);
1843		1816
1844	if (cur_network->network.InfrastructureMode == Ndis802_11IBSS)	1817	if (cur_network->network.InfrastructureMode == Ndis802_11IBSS)

drivers/staging/r8188eu/core/rtw_mlme_ext.c+296−451

@@ -12,24 +12,6 @@ · 11 unmodified lines
12	#include "../include/rtl8188e_xmit.h"	12	#include "../include/rtl8188e_xmit.h"
13	#include "../include/rtl8188e_dm.h"	13	#include "../include/rtl8188e_dm.h"
14		14
15	/* response function for each management frame subtype, do not reorder */
16	static mlme_handler mlme_sta_tbl[] = {
17	OnAssocReq,
18	OnAssocRsp,
19	OnAssocReq,
20	OnAssocRsp,
21	OnProbeReq,
22	OnProbeRsp,
23	NULL,
24	NULL,
25	OnBeacon,
26	NULL,
27	OnDisassoc,
28	OnAuthClient,
29	OnDeAuth,
30	OnAction,
31	};
32
33	static u8 null_addr[ETH_ALEN] = {0, 0, 0, 0, 0, 0};	15	static u8 null_addr[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
34		16
35	/**************************************************	17	/**************************************************
@@ -137,7 +119,7 @@ static struct rt_channel_plan_map RTW_ChannelPlanMap[RT_CHANNEL_DOMAIN_MAX] = { · 101 unmodified lines
137	{0x03}, /* 0x41, RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN_2G */	119	{0x03}, /* 0x41, RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN_2G */
138	};	120	};
139		121
140	static struct rt_channel_plan_map RTW_CHANNEL_PLAN_MAP_REALTEK_DEFINE = {0x03}; /* use the conbination for max channel numbers */	122	static struct rt_channel_plan_map RTW_CHANNEL_PLAN_MAP_REALTEK_DEFINE = {0x03}; /* use the combination for max channel numbers */
141		123
142	/*	124	/*
143	* Search the @param channel_num in given @param channel_set	125	* Search the @param channel_num in given @param channel_set
@@ -393,47 +375,6 @@ void free_mlme_ext_priv(struct mlme_ext_priv *pmlmeext) · 249 unmodified lines
393	}	375	}
394	}	376	}
395		377
396	void mgt_dispatcher(struct adapter padapter, struct recv_frame precv_frame)
397	{
398	int index;
399	mlme_handler fct;
400	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
401	struct ieee80211_hdr hdr = (struct ieee80211_hdr )precv_frame->rx_data;
402	struct sta_info *psta = rtw_get_stainfo(&padapter->stapriv, hdr->addr2);
403
404	if (!ieee80211_is_mgmt(hdr->frame_control))
405	return;
406
407	/* receive the frames that ra(a1) is my address or ra(a1) is bc address. */
408	if (memcmp(hdr->addr1, myid(&padapter->eeprompriv), ETH_ALEN) &&
409	!is_broadcast_ether_addr(hdr->addr1))
410	return;
411
412	index = (le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_STYPE) >> 4;
413	if (index >= ARRAY_SIZE(mlme_sta_tbl))
414	return;
415	fct = mlme_sta_tbl[index];
416
417	if (psta) {
418	if (ieee80211_has_retry(hdr->frame_control)) {
419	if (precv_frame->attrib.seq_num == psta->RxMgmtFrameSeqNum)
420	/* drop the duplicate management frame */
421	return;
422	}
423	psta->RxMgmtFrameSeqNum = precv_frame->attrib.seq_num;
424	}
425
426	if (ieee80211_is_auth(hdr->frame_control)) {
427	if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
428	fct = OnAuth;
429	else
430	fct = OnAuthClient;
431	}
432
433	if (fct)
434	fct(padapter, precv_frame);
435	}
436
437	static u32 p2p_listen_state_process(struct adapter padapter, unsigned char da)	378	static u32 p2p_listen_state_process(struct adapter padapter, unsigned char da)
438	{	379	{
439	bool response = true;	380	bool response = true;
@@ -448,21 +389,6 @@ static u32 p2p_listen_state_process(struct adapter padapter, unsigned char da) · 8 unmodified lines
448	return _SUCCESS;	389	return _SUCCESS;
449	}	390	}
450		391
451	static void update_TSF(struct mlme_ext_priv pmlmeext, u8 pframe)
452	{
453	u8 *pIE;
454	__le32 *pbuf;
455
456	pIE = pframe + sizeof(struct ieee80211_hdr_3addr);
457	pbuf = (__le32 *)pIE;
458
459	pmlmeext->TSFValue = le32_to_cpu(*(pbuf + 1));
460
461	pmlmeext->TSFValue = pmlmeext->TSFValue << 32;
462
463	pmlmeext->TSFValue \|= le32_to_cpu(*pbuf);
464	}
465
466	static void correct_TSF(struct adapter *padapter)	392	static void correct_TSF(struct adapter *padapter)
467	{	393	{
468	u8 reg;	394	u8 reg;
@@ -506,7 +432,7 @@ Following are the callback functions for each subtype of the management frames · 37 unmodified lines
506		432
507	*****************************************************************************/	433	*****************************************************************************/
508		434
509	unsigned int OnProbeReq(struct adapter padapter, struct recv_frame precv_frame)	435	static void OnProbeReq(struct adapter padapter, struct recv_frame precv_frame)
510	{	436	{
511	unsigned int ielen;	437	unsigned int ielen;
512	unsigned char *p;	438	unsigned char *p;
@@ -540,17 +466,17 @@ unsigned int OnProbeReq(struct adapter padapter, struct recv_frame precv_frame · 27 unmodified lines
540	report_survey_event(padapter, precv_frame);	466	report_survey_event(padapter, precv_frame);
541	p2p_listen_state_process(padapter, get_sa(pframe));	467	p2p_listen_state_process(padapter, get_sa(pframe));
542		468
543	return _SUCCESS;	469	return;
544	}	470	}
545	}	471	}
546	}	472	}
547		473
548	if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))	474	if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
549	return _SUCCESS;	475	return;
550		476
551	if (!check_fwstate(pmlmepriv, _FW_LINKED) &&	477	if (!check_fwstate(pmlmepriv, _FW_LINKED) &&
552	!check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE \| WIFI_AP_STATE))	478	!check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE \| WIFI_AP_STATE))
553	return _SUCCESS;	479	return;
554		480
555	p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SSID_IE_, (int *)&ielen,	481	p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SSID_IE_, (int *)&ielen,
556	len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);	482	len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
@@ -562,7 +488,7 @@ unsigned int OnProbeReq(struct adapter padapter, struct recv_frame precv_frame · 5 unmodified lines
562		488
563	if ((ielen != 0 && memcmp((void )(p + 2), (void )cur->Ssid.Ssid, cur->Ssid.SsidLength)) \|\|	489	if ((ielen != 0 && memcmp((void )(p + 2), (void )cur->Ssid.Ssid, cur->Ssid.SsidLength)) \|\|
564	(ielen == 0 && pmlmeinfo->hidden_ssid_mode))	490	(ielen == 0 && pmlmeinfo->hidden_ssid_mode))
565	return _SUCCESS;	491	return;
566		492
567	_issue_probersp:	493	_issue_probersp:
568		494
@@ -571,10 +497,9 @@ _issue_probersp: · 2 unmodified lines
571	check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))	497	check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
572	issue_probersp(padapter, get_sa(pframe), is_valid_p2p_probereq);	498	issue_probersp(padapter, get_sa(pframe), is_valid_p2p_probereq);
573	}	499	}
574	return _SUCCESS;
575	}	500	}
576		501
577	unsigned int OnProbeRsp(struct adapter padapter, struct recv_frame precv_frame)	502	static void OnProbeRsp(struct adapter padapter, struct recv_frame precv_frame)
578	{	503	{
579	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	504	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
580	struct wifidirect_info *pwdinfo = &padapter->wdinfo;	505	struct wifidirect_info *pwdinfo = &padapter->wdinfo;
@@ -596,7 +521,7 @@ unsigned int OnProbeRsp(struct adapter padapter, struct recv_frame precv_frame · 15 unmodified lines
596	}	521	}
597	}	522	}
598	}	523	}
599	return _SUCCESS;	524	return;
600	} else if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING)) {	525	} else if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING)) {
601	if (pwdinfo->nego_req_info.benable) {	526	if (pwdinfo->nego_req_info.benable) {
602	if (!memcmp(pwdinfo->nego_req_info.peerDevAddr, GetAddr2Ptr(pframe), ETH_ALEN)) {	527	if (!memcmp(pwdinfo->nego_req_info.peerDevAddr, GetAddr2Ptr(pframe), ETH_ALEN)) {
@@ -614,14 +539,13 @@ unsigned int OnProbeRsp(struct adapter padapter, struct recv_frame precv_frame · 11 unmodified lines
614	}	539	}
615	if (pmlmeext->sitesurvey_res.state == SCAN_PROCESS) {	540	if (pmlmeext->sitesurvey_res.state == SCAN_PROCESS) {
616	report_survey_event(padapter, precv_frame);	541	report_survey_event(padapter, precv_frame);
617	return _SUCCESS;	542	return;
618	}	543	}
619
620	return _SUCCESS;
621	}	544	}
622		545
623	unsigned int OnBeacon(struct adapter padapter, struct recv_frame precv_frame)	546	static void OnBeacon(struct adapter padapter, struct recv_frame precv_frame)
624	{	547	{
		548	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;
625	int cam_idx;	549	int cam_idx;
626	struct sta_info *psta;	550	struct sta_info *psta;
627	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	551	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
@@ -631,86 +555,86 @@ unsigned int OnBeacon(struct adapter padapter, struct recv_frame precv_frame) · 3 unmodified lines
631	u8 *pframe = precv_frame->rx_data;	555	u8 *pframe = precv_frame->rx_data;
632	uint len = precv_frame->len;	556	uint len = precv_frame->len;
633	struct wlan_bssid_ex *pbss;	557	struct wlan_bssid_ex *pbss;
634	int ret = _SUCCESS;	558	u8 *ie_ptr;
		559	u32 ie_len;
		560
		561	ie_ptr = (u8 *)&mgmt->u.beacon.variable;
		562	if (precv_frame->len < offsetof(struct ieee80211_mgmt, u.beacon.variable))
		563	return;
		564	ie_len = precv_frame->len - offsetof(struct ieee80211_mgmt, u.beacon.variable);
635		565
636	if (pmlmeext->sitesurvey_res.state == SCAN_PROCESS) {	566	if (pmlmeext->sitesurvey_res.state == SCAN_PROCESS) {
637	report_survey_event(padapter, precv_frame);	567	report_survey_event(padapter, precv_frame);
638	return _SUCCESS;	568	return;
639	}	569	}
640		570
641	if (!memcmp(GetAddr3Ptr(pframe), get_my_bssid(&pmlmeinfo->network), ETH_ALEN)) {	571	if (memcmp(mgmt->bssid, get_my_bssid(&pmlmeinfo->network), ETH_ALEN))
642	if (pmlmeinfo->state & WIFI_FW_AUTH_NULL) {	572	return;
643	/* we should update current network before auth, or some IE is wrong */
644	pbss = kmalloc(sizeof(struct wlan_bssid_ex), GFP_ATOMIC);
645	if (pbss) {
646	if (collect_bss_info(padapter, precv_frame, pbss) == _SUCCESS) {
647	update_network(&pmlmepriv->cur_network.network, pbss, padapter, true);
648	rtw_get_bcn_info(&pmlmepriv->cur_network);
649	}
650	kfree(pbss);
651	}
652		573
653	/* check the vendor of the assoc AP */	574	if (pmlmeinfo->state & WIFI_FW_AUTH_NULL) {
654	pmlmeinfo->assoc_AP_vendor = check_assoc_AP(pframe + sizeof(struct ieee80211_hdr_3addr), len - sizeof(struct ieee80211_hdr_3addr));	575	/* we should update current network before auth, or some IE is wrong */
		576	pbss = kmalloc(sizeof(struct wlan_bssid_ex), GFP_ATOMIC);
		577	if (!pbss)
		578	return;
655		579
656	/* update TSF Value */	580	if (collect_bss_info(padapter, precv_frame, pbss) == _SUCCESS) {
657	update_TSF(pmlmeext, pframe);	581	update_network(&pmlmepriv->cur_network.network, pbss, padapter, true);
		582	rtw_get_bcn_info(&pmlmepriv->cur_network);
		583	}
		584	kfree(pbss);
658		585
659	/* start auth */	586	/* check the vendor of the assoc AP */
660	start_clnt_auth(padapter);	587	pmlmeinfo->assoc_AP_vendor = check_assoc_AP(pframe + sizeof(struct ieee80211_hdr_3addr), len - sizeof(struct ieee80211_hdr_3addr));
661		588
662	return _SUCCESS;	589	pmlmeext->TSFValue = le64_to_cpu(mgmt->u.beacon.timestamp);
		590
		591	/* start auth */
		592	start_clnt_auth(padapter);
		593
		594	return;
		595	}
		596
		597	if (((pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE) && (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)) {
		598	psta = rtw_get_stainfo(pstapriv, mgmt->sa);
		599	if (!psta)
		600	return;
		601
		602	if (rtw_check_bcn_info(padapter, pframe, len) != _SUCCESS) {
		603	receive_disconnect(padapter, pmlmeinfo->network.MacAddress, 0);
		604	return;
663	}	605	}
		606	/* update WMM, ERP in the beacon */
		607	/* todo: the timer is used instead of the number of the beacon received */
		608	if ((sta_rx_pkts(psta) & 0xf) == 0)
		609	update_beacon_info(padapter, ie_ptr, ie_len, psta);
		610	process_p2p_ps_ie(padapter, ie_ptr, ie_len);
		611	} else if ((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE) {
		612	psta = rtw_get_stainfo(pstapriv, mgmt->sa);
		613	if (psta) {
		614	/* update WMM, ERP in the beacon */
		615	/* todo: the timer is used instead of the number of the beacon received */
		616	if ((sta_rx_pkts(psta) & 0xf) == 0)
		617	update_beacon_info(padapter, ie_ptr, ie_len, psta);
		618	} else {
		619	/* allocate a new CAM entry for IBSS station */
		620	cam_idx = allocate_fw_sta_entry(padapter);
		621	if (cam_idx == NUM_STA)
		622	return;
664		623
665	if (((pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE) && (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)) {	624	/* get supported rate */
666	psta = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));	625	if (update_sta_support_rate(padapter, ie_ptr, ie_len, cam_idx) == _FAIL) {
667	if (psta) {	626	pmlmeinfo->FW_sta_info[cam_idx].status = 0;
668	ret = rtw_check_bcn_info(padapter, pframe, len);	627	return;
669	if (!ret) {
670	receive_disconnect(padapter,
671	pmlmeinfo->network.MacAddress, 0);
672	return _SUCCESS;
673	}
674	/* update WMM, ERP in the beacon */
675	/* todo: the timer is used instead of the number of the beacon received */
676	if ((sta_rx_pkts(psta) & 0xf) == 0)
677	update_beacon_info(padapter, pframe, len, psta);
678	process_p2p_ps_ie(padapter, (pframe + WLAN_HDR_A3_LEN), (len - WLAN_HDR_A3_LEN));
679	}	628	}
680	} else if ((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE) {
681	psta = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));
682	if (psta) {
683	/* update WMM, ERP in the beacon */
684	/* todo: the timer is used instead of the number of the beacon received */
685	if ((sta_rx_pkts(psta) & 0xf) == 0)
686	update_beacon_info(padapter, pframe, len, psta);
687	} else {
688	/* allocate a new CAM entry for IBSS station */
689	cam_idx = allocate_fw_sta_entry(padapter);
690	if (cam_idx == NUM_STA)
691	goto _END_ONBEACON_;
692
693	/* get supported rate */
694	if (update_sta_support_rate(padapter, (pframe + WLAN_HDR_A3_LEN + _BEACON_IE_OFFSET_), (len - WLAN_HDR_A3_LEN - _BEACON_IE_OFFSET_), cam_idx) == _FAIL) {
695	pmlmeinfo->FW_sta_info[cam_idx].status = 0;
696	goto _END_ONBEACON_;
697	}
698		629
699	/* update TSF Value */	630	pmlmeext->TSFValue = le64_to_cpu(mgmt->u.beacon.timestamp);
700	update_TSF(pmlmeext, pframe);
701		631
702	/* report sta add event */	632	report_add_sta_event(padapter, mgmt->sa, cam_idx);
703	report_add_sta_event(padapter, GetAddr2Ptr(pframe), cam_idx);
704	}
705	}	633	}
706	}	634	}
707
708	_END_ONBEACON_:
709
710	return _SUCCESS;
711	}	635	}
712		636
713	unsigned int OnAuth(struct adapter padapter, struct recv_frame precv_frame)	637	static void OnAuth(struct adapter padapter, struct recv_frame precv_frame)
714	{	638	{
715	unsigned int auth_mode, ie_len;	639	unsigned int auth_mode, ie_len;
716	u16 seq;	640	u16 seq;
@@ -727,7 +651,7 @@ unsigned int OnAuth(struct adapter padapter, struct recv_frame precv_frame) · 10 unmodified lines
727	uint len = precv_frame->len;	651	uint len = precv_frame->len;
728		652
729	if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)	653	if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
730	return _FAIL;	654	return;
731		655
732	sa = GetAddr2Ptr(pframe);	656	sa = GetAddr2Ptr(pframe);
733		657
@@ -843,7 +767,7 @@ unsigned int OnAuth(struct adapter padapter, struct recv_frame precv_frame) · 109 unmodified lines
843	if (pstat->state & WIFI_FW_AUTH_SUCCESS)	767	if (pstat->state & WIFI_FW_AUTH_SUCCESS)
844	pstat->auth_seq = 0;	768	pstat->auth_seq = 0;
845		769
846	return _SUCCESS;	770	return;
847		771
848	auth_fail:	772	auth_fail:
849		773
@@ -856,27 +780,26 @@ auth_fail: · 6 unmodified lines
856	memcpy(pstat->hwaddr, sa, 6);	780	memcpy(pstat->hwaddr, sa, 6);
857		781
858	issue_auth(padapter, pstat, (unsigned short)status);	782	issue_auth(padapter, pstat, (unsigned short)status);
859	return _FAIL;
860	}	783	}
861		784
862	unsigned int OnAuthClient(struct adapter padapter, struct recv_frame precv_frame)	785	static void OnAuthClient(struct adapter padapter, struct recv_frame precv_frame)
863	{	786	{
864	unsigned int seq, len, status, offset;	787	unsigned int seq, len, status, offset;
865	unsigned char *p;	788	unsigned char *p;
866	unsigned int go2asoc = 0;
867	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	789	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
868	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;	790	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
		791	struct ieee80211_hdr hdr = (struct ieee80211_hdr )precv_frame->rx_data;
869	u8 *pframe = precv_frame->rx_data;	792	u8 *pframe = precv_frame->rx_data;
870	uint pkt_len = precv_frame->len;	793	uint pkt_len = precv_frame->len;
871		794
872	/* check A1 matches or not */	795	/* check A1 matches or not */
873	if (memcmp(myid(&padapter->eeprompriv), get_da(pframe), ETH_ALEN))	796	if (memcmp(myid(&padapter->eeprompriv), ieee80211_get_DA(hdr), ETH_ALEN))
874	return _SUCCESS;	797	return;
875		798
876	if (!(pmlmeinfo->state & WIFI_FW_AUTH_STATE))	799	if (!(pmlmeinfo->state & WIFI_FW_AUTH_STATE))
877	return _SUCCESS;	800	return;
878		801
879	offset = (GetPrivacy(pframe)) ? 4 : 0;	802	offset = ieee80211_has_protected(hdr->frame_control) ? 4 : 0;
880		803
881	seq = le16_to_cpu((__le16 )((size_t)pframe + WLAN_HDR_A3_LEN + offset + 2));	804	seq = le16_to_cpu((__le16 )((size_t)pframe + WLAN_HDR_A3_LEN + offset + 2));
882	status = le16_to_cpu((__le16 )((size_t)pframe + WLAN_HDR_A3_LEN + offset + 4));	805	status = le16_to_cpu((__le16 )((size_t)pframe + WLAN_HDR_A3_LEN + offset + 4));
@@ -890,7 +813,7 @@ unsigned int OnAuthClient(struct adapter padapter, struct recv_frame precv_fra · 7 unmodified lines
890	}	813	}
891		814
892	set_link_timer(pmlmeext, 1);	815	set_link_timer(pmlmeext, 1);
893	goto authclnt_fail;	816	return;
894	}	817	}
895		818
896	if (seq == 2) {	819	if (seq == 2) {
@@ -900,34 +823,22 @@ unsigned int OnAuthClient(struct adapter padapter, struct recv_frame precv_fra · 3 unmodified lines
900	pkt_len - WLAN_HDR_A3_LEN - _AUTH_IE_OFFSET_);	823	pkt_len - WLAN_HDR_A3_LEN - _AUTH_IE_OFFSET_);
901		824
902	if (!p)	825	if (!p)
903	goto authclnt_fail;	826	return;
904		827
905	memcpy((void )(pmlmeinfo->chg_txt), (void )(p + 2), len);	828	memcpy((void )(pmlmeinfo->chg_txt), (void )(p + 2), len);
906	pmlmeinfo->auth_seq = 3;	829	pmlmeinfo->auth_seq = 3;
907	issue_auth(padapter, NULL, 0);	830	issue_auth(padapter, NULL, 0);
908	set_link_timer(pmlmeext, REAUTH_TO);	831	set_link_timer(pmlmeext, REAUTH_TO);
909		832
910	return _SUCCESS;	833	return;
911	} else {	834	} else {
912	/* open system */	835	/* open system */
913	go2asoc = 1;	836	start_clnt_assoc(padapter);
914	}	837	}
915	} else if (seq == 4) {	838	} else if (seq == 4) {
916	if (pmlmeinfo->auth_algo == dot11AuthAlgrthm_Shared)	839	if (pmlmeinfo->auth_algo == dot11AuthAlgrthm_Shared)
917	go2asoc = 1;	840	start_clnt_assoc(padapter);
918	else
919	goto authclnt_fail;
920	} else {
921	/* this is also illegal */
922	goto authclnt_fail;
923	}	841	}
924
925	if (go2asoc) {
926	start_clnt_assoc(padapter);
927	return _SUCCESS;
928	}
929	authclnt_fail:
930	return _FAIL;
931	}	842	}
932		843
933	static void UpdateBrateTbl(u8 *mbrate)	844	static void UpdateBrateTbl(u8 *mbrate)
@@ -970,7 +881,7 @@ static void UpdateBrateTblForSoftAP(u8 *bssrateset, u32 bssratelen) · 36 unmodified lines
970	}	881	}
971	}	882	}
972		883
973	unsigned int OnAssocReq(struct adapter padapter, struct recv_frame precv_frame)	884	static void OnAssocReq(struct adapter padapter, struct recv_frame precv_frame)
974	{	885	{
975	u16 capab_info;	886	u16 capab_info;
976	struct rtw_ieee802_11_elems elems;	887	struct rtw_ieee802_11_elems elems;
@@ -996,7 +907,7 @@ unsigned int OnAssocReq(struct adapter padapter, struct recv_frame precv_frame · 19 unmodified lines
996	u32 p2pielen = 0;	907	u32 p2pielen = 0;
997		908
998	if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)	909	if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
999	return _FAIL;	910	return;
1000		911
1001	frame_type = GetFrameSubType(pframe);	912	frame_type = GetFrameSubType(pframe);
1002	if (frame_type == WIFI_ASSOCREQ)	913	if (frame_type == WIFI_ASSOCREQ)
@@ -1005,7 +916,7 @@ unsigned int OnAssocReq(struct adapter padapter, struct recv_frame precv_frame · 2 unmodified lines
1005	ie_offset = _REASOCREQ_IE_OFFSET_;	916	ie_offset = _REASOCREQ_IE_OFFSET_;
1006		917
1007	if (pkt_len < IEEE80211_3ADDR_LEN + ie_offset)	918	if (pkt_len < IEEE80211_3ADDR_LEN + ie_offset)
1008	return _FAIL;	919	return;
1009		920
1010	pstat = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));	921	pstat = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));
1011	if (pstat == (struct sta_info *)NULL) {	922	if (pstat == (struct sta_info *)NULL) {
@@ -1359,13 +1270,13 @@ unsigned int OnAssocReq(struct adapter padapter, struct recv_frame precv_frame · 347 unmodified lines
1359	report_add_sta_event(padapter, pstat->hwaddr, pstat->aid);	1270	report_add_sta_event(padapter, pstat->hwaddr, pstat->aid);
1360	}	1271	}
1361		1272
1362	return _SUCCESS;	1273	return;
1363		1274
1364	asoc_class2_error:	1275	asoc_class2_error:
1365		1276
1366	issue_deauth(padapter, (void *)GetAddr2Ptr(pframe), status);	1277	issue_deauth(padapter, (void *)GetAddr2Ptr(pframe), status);
1367		1278
1368	return _FAIL;	1279	return;
1369		1280
1370	OnAssocReqFail:	1281	OnAssocReqFail:
1371		1282
@@ -1375,10 +1286,10 @@ OnAssocReqFail: · 3 unmodified lines
1375	else	1286	else
1376	issue_asocrsp(padapter, status, pstat, WIFI_REASSOCRSP);	1287	issue_asocrsp(padapter, status, pstat, WIFI_REASSOCRSP);
1377		1288
1378	return _FAIL;	1289	return;
1379	}	1290	}
1380		1291
1381	unsigned int OnAssocRsp(struct adapter padapter, struct recv_frame precv_frame)	1292	static void OnAssocRsp(struct adapter padapter, struct recv_frame precv_frame)
1382	{	1293	{
1383	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;	1294	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;
1384	uint i;	1295	uint i;
@@ -1392,13 +1303,13 @@ unsigned int OnAssocRsp(struct adapter padapter, struct recv_frame precv_frame · 7 unmodified lines
1392		1303
1393	/* check A1 matches or not */	1304	/* check A1 matches or not */
1394	if (memcmp(myid(&padapter->eeprompriv), mgmt->da, ETH_ALEN))	1305	if (memcmp(myid(&padapter->eeprompriv), mgmt->da, ETH_ALEN))
1395	return _SUCCESS;	1306	return;
1396		1307
1397	if (!(pmlmeinfo->state & (WIFI_FW_AUTH_SUCCESS \| WIFI_FW_ASSOC_STATE)))	1308	if (!(pmlmeinfo->state & (WIFI_FW_AUTH_SUCCESS \| WIFI_FW_ASSOC_STATE)))
1398	return _SUCCESS;	1309	return;
1399		1310
1400	if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)	1311	if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)
1401	return _SUCCESS;	1312	return;
1402		1313
1403	_cancel_timer_ex(&pmlmeext->link_timer);	1314	_cancel_timer_ex(&pmlmeext->link_timer);
1404		1315
@@ -1451,163 +1362,143 @@ unsigned int OnAssocRsp(struct adapter padapter, struct recv_frame precv_frame · 46 unmodified lines
1451		1362
1452	report_assoc_result:	1363	report_assoc_result:
1453	report_join_res(padapter, res);	1364	report_join_res(padapter, res);
1454
1455	return _SUCCESS;
1456	}	1365	}
1457		1366
1458	unsigned int OnDeAuth(struct adapter padapter, struct recv_frame precv_frame)	1367	static void OnDeAuth(struct adapter padapter, struct recv_frame precv_frame)
1459	{	1368	{
		1369	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;
1460	unsigned short reason;	1370	unsigned short reason;
1461	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;	1371	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1462	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	1372	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1463	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;	1373	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
1464	u8 *pframe = precv_frame->rx_data;
1465	struct wifidirect_info *pwdinfo = &padapter->wdinfo;	1374	struct wifidirect_info *pwdinfo = &padapter->wdinfo;
1466		1375
1467	/* check A3 */	1376	if (memcmp(mgmt->bssid, get_my_bssid(&pmlmeinfo->network), ETH_ALEN))
1468	if (!(!memcmp(GetAddr3Ptr(pframe), get_my_bssid(&pmlmeinfo->network), ETH_ALEN)))	1377	return;
1469	return _SUCCESS;
1470		1378
1471	if (pwdinfo->rx_invitereq_info.scan_op_ch_only) {	1379	if (pwdinfo->rx_invitereq_info.scan_op_ch_only) {
1472	_cancel_timer_ex(&pwdinfo->reset_ch_sitesurvey);	1380	_cancel_timer_ex(&pwdinfo->reset_ch_sitesurvey);
1473	_set_timer(&pwdinfo->reset_ch_sitesurvey, 10);	1381	_set_timer(&pwdinfo->reset_ch_sitesurvey, 10);
1474	}	1382	}
1475		1383
1476	reason = le16_to_cpu((__le16 )(pframe + WLAN_HDR_A3_LEN));	1384	reason = le16_to_cpu(mgmt->u.disassoc.reason_code);
1477		1385
1478	if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {	1386	if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1479	struct sta_info *psta;	1387	struct sta_info *psta;
1480	struct sta_priv *pstapriv = &padapter->stapriv;	1388	struct sta_priv *pstapriv = &padapter->stapriv;
		1389	u8 updated = 0;
1481		1390
1482	psta = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));	1391	psta = rtw_get_stainfo(pstapriv, mgmt->sa);
1483	if (psta) {	1392	if (!psta)
1484	u8 updated = 0;	1393	return;
1485
1486	spin_lock_bh(&pstapriv->asoc_list_lock);
1487	if (!list_empty(&psta->asoc_list)) {
1488	list_del_init(&psta->asoc_list);
1489	pstapriv->asoc_list_cnt--;
1490	updated = ap_free_sta(padapter, psta, false, reason);
1491	}
1492	spin_unlock_bh(&pstapriv->asoc_list_lock);
1493		1394
1494	associated_clients_update(padapter, updated);	1395	spin_lock_bh(&pstapriv->asoc_list_lock);
		1396	if (!list_empty(&psta->asoc_list)) {
		1397	list_del_init(&psta->asoc_list);
		1398	pstapriv->asoc_list_cnt--;
		1399	updated = ap_free_sta(padapter, psta, false, reason);
1495	}	1400	}
		1401	spin_unlock_bh(&pstapriv->asoc_list_lock);
1496		1402
1497	return _SUCCESS;	1403	associated_clients_update(padapter, updated);
1498	} else {	1404	} else {
1499	int ignore_received_deauth = 0;	1405	bool ignore_received_deauth = false;
1500		1406
1501	/* Before sending the auth frame to start the STA/GC mode connection with AP/GO,	1407	/* Before sending the auth frame to start the STA/GC mode connection with AP/GO,
1502	* we will send the deauth first.	1408	* we will send the deauth first.
1503	* However, the Win8.1 with BRCM Wi-Fi will send the deauth with reason code 6 to us after receieving our deauth.	1409	* However, the Win8.1 with BRCM Wi-Fi will send the deauth with reason code 6 to us after receieving our deauth.
1504	* Added the following code to avoid this case.	1410	* Added the following code to avoid this case.
1505	*/	1411	*/
1506	if ((pmlmeinfo->state & WIFI_FW_AUTH_STATE) \|\|	1412	if (pmlmeinfo->state & (WIFI_FW_AUTH_STATE \| WIFI_FW_ASSOC_STATE)) {
1507	(pmlmeinfo->state & WIFI_FW_ASSOC_STATE)) {
1508	if (reason == WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA) {	1413	if (reason == WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA) {
1509	ignore_received_deauth = 1;	1414	ignore_received_deauth = true;
1510	} else if (reason == WLAN_REASON_PREV_AUTH_NOT_VALID) {	1415	} else if (reason == WLAN_REASON_PREV_AUTH_NOT_VALID) {
1511	// TODO: 802.11r	1416	// TODO: 802.11r
1512	ignore_received_deauth = 1;	1417	ignore_received_deauth = true;
1513	}	1418	}
1514	}	1419	}
1515		1420
1516	if (!ignore_received_deauth)	1421	if (!ignore_received_deauth)
1517	receive_disconnect(padapter, GetAddr3Ptr(pframe), reason);	1422	receive_disconnect(padapter, mgmt->bssid, reason);
		1423
		1424	pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
1518	}	1425	}
1519	pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
1520	return _SUCCESS;
1521	}	1426	}
1522		1427
1523	unsigned int OnDisassoc(struct adapter padapter, struct recv_frame precv_frame)	1428	static void OnDisassoc(struct adapter padapter, struct recv_frame precv_frame)
1524	{	1429	{
		1430	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;
1525	u16 reason;	1431	u16 reason;
1526	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;	1432	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1527	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	1433	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1528	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;	1434	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
1529	u8 *pframe = precv_frame->rx_data;
1530	struct wifidirect_info *pwdinfo = &padapter->wdinfo;	1435	struct wifidirect_info *pwdinfo = &padapter->wdinfo;
		1436	struct sta_info *psta;
		1437	struct sta_priv *pstapriv = &padapter->stapriv;
		1438	u8 updated = 0;
1531		1439
1532	/* check A3 */	1440	if (memcmp(mgmt->bssid, get_my_bssid(&pmlmeinfo->network), ETH_ALEN))
1533	if (!(!memcmp(GetAddr3Ptr(pframe), get_my_bssid(&pmlmeinfo->network), ETH_ALEN)))	1441	return;
1534	return _SUCCESS;
1535		1442
1536	if (pwdinfo->rx_invitereq_info.scan_op_ch_only) {	1443	if (pwdinfo->rx_invitereq_info.scan_op_ch_only) {
1537	_cancel_timer_ex(&pwdinfo->reset_ch_sitesurvey);	1444	_cancel_timer_ex(&pwdinfo->reset_ch_sitesurvey);
1538	_set_timer(&pwdinfo->reset_ch_sitesurvey, 10);	1445	_set_timer(&pwdinfo->reset_ch_sitesurvey, 10);
1539	}	1446	}
1540		1447
1541	reason = le16_to_cpu((__le16 )(pframe + WLAN_HDR_A3_LEN));	1448	reason = le16_to_cpu(mgmt->u.disassoc.reason_code);
1542
1543	if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1544	struct sta_info *psta;
1545	struct sta_priv *pstapriv = &padapter->stapriv;
1546
1547	psta = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));
1548	if (psta) {
1549	u8 updated = 0;
1550		1449
1551	spin_lock_bh(&pstapriv->asoc_list_lock);	1450	if (!check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1552	if (!list_empty(&psta->asoc_list)) {	1451	receive_disconnect(padapter, mgmt->bssid, reason);
1553	list_del_init(&psta->asoc_list);	1452	pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
1554	pstapriv->asoc_list_cnt--;	1453	return;
1555	updated = ap_free_sta(padapter, psta, false, reason);	1454	}
1556	}
1557	spin_unlock_bh(&pstapriv->asoc_list_lock);
1558		1455
1559	associated_clients_update(padapter, updated);	1456	psta = rtw_get_stainfo(pstapriv, mgmt->sa);
1560	}	1457	if (!psta)
		1458	return;
1561		1459
1562	return _SUCCESS;	1460	spin_lock_bh(&pstapriv->asoc_list_lock);
1563	} else {	1461	if (!list_empty(&psta->asoc_list)) {
1564	receive_disconnect(padapter, GetAddr3Ptr(pframe), reason);	1462	list_del_init(&psta->asoc_list);
		1463	pstapriv->asoc_list_cnt--;
		1464	updated = ap_free_sta(padapter, psta, false, reason);
1565	}	1465	}
1566	pmlmepriv->LinkDetectInfo.bBusyTraffic = false;	1466	spin_unlock_bh(&pstapriv->asoc_list_lock);
1567	return _SUCCESS;	1467
		1468	associated_clients_update(padapter, updated);
1568	}	1469	}
1569		1470
1570	unsigned int OnAction_back(struct adapter padapter, struct recv_frame precv_frame)	1471	static void OnAction_back(struct adapter padapter, struct recv_frame precv_frame)
1571	{	1472	{
1572	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;	1473	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;
1573	struct sta_info *psta = NULL;	1474	struct sta_info *psta = NULL;
1574	struct recv_reorder_ctrl *preorder_ctrl;	1475	struct recv_reorder_ctrl *preorder_ctrl;
1575	unsigned char *frame_body;
1576	unsigned short tid;	1476	unsigned short tid;
1577	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	1477	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1578	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;	1478	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
1579	u8 *pframe = precv_frame->rx_data;
1580	struct sta_priv *pstapriv = &padapter->stapriv;	1479	struct sta_priv *pstapriv = &padapter->stapriv;
1581	/* check RA matches or not */
1582	if (memcmp(myid(&padapter->eeprompriv), mgmt->da, ETH_ALEN))/* for if1, sta/ap mode */
1583	return _SUCCESS;
1584		1480
1585	if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)	1481	if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
1586	if (!(pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS))	1482	if (!(pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS))
1587	return _SUCCESS;	1483	return;
1588		1484
1589	psta = rtw_get_stainfo(pstapriv, mgmt->sa);	1485	psta = rtw_get_stainfo(pstapriv, mgmt->sa);
1590
1591	if (!psta)	1486	if (!psta)
1592	return _SUCCESS;	1487	return;
1593
1594	frame_body = (unsigned char *)(pframe + sizeof(struct ieee80211_hdr_3addr));
1595		1488
1596	if (!pmlmeinfo->HT_enable)	1489	if (!pmlmeinfo->HT_enable)
1597	return _SUCCESS;	1490	return;
1598	/* All union members start with an action code, it's ok to use addba_req. */	1491	/* All union members start with an action code, it's ok to use addba_req. */
1599	switch (mgmt->u.action.u.addba_req.action_code) {	1492	switch (mgmt->u.action.u.addba_req.action_code) {
1600	case WLAN_ACTION_ADDBA_REQ:	1493	case WLAN_ACTION_ADDBA_REQ:
1601	memcpy(&pmlmeinfo->ADDBA_req, &frame_body[2], sizeof(struct ADDBA_request));
1602	tid = u16_get_bits(le16_to_cpu(mgmt->u.action.u.addba_req.capab),	1494	tid = u16_get_bits(le16_to_cpu(mgmt->u.action.u.addba_req.capab),
1603	IEEE80211_ADDBA_PARAM_TID_MASK);	1495	IEEE80211_ADDBA_PARAM_TID_MASK);
1604	preorder_ctrl = &psta->recvreorder_ctrl[tid];	1496	preorder_ctrl = &psta->recvreorder_ctrl[tid];
1605	preorder_ctrl->indicate_seq = 0xffff;	1497	preorder_ctrl->indicate_seq = 0xffff;
1606	preorder_ctrl->enable = pmlmeinfo->bAcceptAddbaReq;	1498	preorder_ctrl->enable = pmlmeinfo->bAcceptAddbaReq;
1607
1608	issue_action_BA(padapter, mgmt->sa, WLAN_ACTION_ADDBA_RESP,	1499	issue_action_BA(padapter, mgmt->sa, WLAN_ACTION_ADDBA_RESP,
1609	pmlmeinfo->bAcceptAddbaReq ?	1500	pmlmeinfo->bAcceptAddbaReq ?
1610	WLAN_STATUS_SUCCESS : WLAN_STATUS_REQUEST_DECLINED);	1501	WLAN_STATUS_SUCCESS : WLAN_STATUS_REQUEST_DECLINED, mgmt);
1611	break;	1502	break;
1612	case WLAN_ACTION_ADDBA_RESP:	1503	case WLAN_ACTION_ADDBA_RESP:
1613	tid = u16_get_bits(le16_to_cpu(mgmt->u.action.u.addba_resp.capab),	1504	tid = u16_get_bits(le16_to_cpu(mgmt->u.action.u.addba_resp.capab),
@@ -1636,8 +1527,6 @@ unsigned int OnAction_back(struct adapter padapter, struct recv_frame precv_fr · 22 unmodified lines
1636	default:	1527	default:
1637	break;	1528	break;
1638	}	1529	}
1639
1640	return _SUCCESS;
1641	}	1530	}
1642		1531
1643	static int get_reg_classes_full_count(struct p2p_channels *channel_list)	1532	static int get_reg_classes_full_count(struct p2p_channels *channel_list)
@@ -1754,7 +1643,7 @@ void issue_p2p_GO_request(struct adapter padapter, u8 raddr) · 110 unmodified lines
1754	p2pie[p2pielen++] = 0x09; /* WFA P2P v1.0 */	1643	p2pie[p2pielen++] = 0x09; /* WFA P2P v1.0 */
1755		1644
1756	/* Commented by Albert 20110306 */	1645	/* Commented by Albert 20110306 */
1757	/* According to the P2P Specification, the group negoitation request frame should contain 9 P2P attributes */	1646	/* According to the P2P Specification, the group negotiation request frame should contain 9 P2P attributes */
1758	/* 1. P2P Capability */	1647	/* 1. P2P Capability */
1759	/* 2. Group Owner Intent */	1648	/* 2. Group Owner Intent */
1760	/* 3. Configuration Timeout */	1649	/* 3. Configuration Timeout */
@@ -2109,7 +1998,7 @@ static void issue_p2p_GO_response(struct adapter padapter, u8 raddr, u8 *frame · 348 unmodified lines
2109	p2pie[p2pielen++] = 0x09; /* WFA P2P v1.0 */	1998	p2pie[p2pielen++] = 0x09; /* WFA P2P v1.0 */
2110		1999
2111	/* Commented by Albert 20100908 */	2000	/* Commented by Albert 20100908 */
2112	/* According to the P2P Specification, the group negoitation response frame should contain 9 P2P attributes */	2001	/* According to the P2P Specification, the group negotiation response frame should contain 9 P2P attributes */
2113	/* 1. Status */	2002	/* 1. Status */
2114	/* 2. P2P Capability */	2003	/* 2. P2P Capability */
2115	/* 3. Group Owner Intent */	2004	/* 3. Group Owner Intent */
@@ -2405,7 +2294,7 @@ static void issue_p2p_GO_confirm(struct adapter padapter, u8 raddr, u8 result) · 289 unmodified lines
2405	p2pie[p2pielen++] = 0x09; /* WFA P2P v1.0 */	2294	p2pie[p2pielen++] = 0x09; /* WFA P2P v1.0 */
2406		2295
2407	/* Commented by Albert 20110306 */	2296	/* Commented by Albert 20110306 */
2408	/* According to the P2P Specification, the group negoitation request frame should contain 5 P2P attributes */	2297	/* According to the P2P Specification, the group negotiation request frame should contain 5 P2P attributes */
2409	/* 1. Status */	2298	/* 1. Status */
2410	/* 2. P2P Capability */	2299	/* 2. P2P Capability */
2411	/* 3. Operating Channel */	2300	/* 3. Operating Channel */
@@ -3294,9 +3183,8 @@ void issue_probersp_p2p(struct adapter padapter, unsigned char da) · 882 unmodified lines
3294	dump_mgntframe(padapter, pmgntframe);	3183	dump_mgntframe(padapter, pmgntframe);
3295	}	3184	}
3296		3185
3297	static int _issue_probereq_p2p(struct adapter padapter, u8 da, int wait_ack)	3186	inline void issue_probereq_p2p(struct adapter *padapter)
3298	{	3187	{
3299	int ret = _FAIL;
3300	struct xmit_frame *pmgntframe;	3188	struct xmit_frame *pmgntframe;
3301	struct pkt_attrib *pattrib;	3189	struct pkt_attrib *pattrib;
3302	unsigned char *pframe;	3190	unsigned char *pframe;
@@ -3312,7 +3200,7 @@ static int _issue_probereq_p2p(struct adapter padapter, u8 da, int wait_ack) · 9 unmodified lines
3312		3200
3313	pmgntframe = alloc_mgtxmitframe(pxmitpriv);	3201	pmgntframe = alloc_mgtxmitframe(pxmitpriv);
3314	if (!pmgntframe)	3202	if (!pmgntframe)
3315	goto exit;	3203	return;
3316		3204
3317	/* update attribute */	3205	/* update attribute */
3318	pattrib = &pmgntframe->attrib;	3206	pattrib = &pmgntframe->attrib;
@@ -3328,20 +3216,16 @@ static int _issue_probereq_p2p(struct adapter padapter, u8 da, int wait_ack) · 9 unmodified lines
3328	fctrl = &pwlanhdr->frame_control;	3216	fctrl = &pwlanhdr->frame_control;
3329	*(fctrl) = 0;	3217	*(fctrl) = 0;
3330		3218
3331	if (da) {	3219	if ((pwdinfo->p2p_info.scan_op_ch_only) \|\| (pwdinfo->rx_invitereq_info.scan_op_ch_only)) {
3332	memcpy(pwlanhdr->addr1, da, ETH_ALEN);	3220	/* This two flags will be set when this is only the P2P client mode. */
3333	memcpy(pwlanhdr->addr3, da, ETH_ALEN);	3221	memcpy(pwlanhdr->addr1, pwdinfo->p2p_peer_interface_addr, ETH_ALEN);
		3222	memcpy(pwlanhdr->addr3, pwdinfo->p2p_peer_interface_addr, ETH_ALEN);
3334	} else {	3223	} else {
3335	if ((pwdinfo->p2p_info.scan_op_ch_only) \|\| (pwdinfo->rx_invitereq_info.scan_op_ch_only)) {	3224	/* broadcast probe request frame */
3336	/* This two flags will be set when this is only the P2P client mode. */	3225	eth_broadcast_addr(pwlanhdr->addr1);
3337	memcpy(pwlanhdr->addr1, pwdinfo->p2p_peer_interface_addr, ETH_ALEN);	3226	eth_broadcast_addr(pwlanhdr->addr3);
3338	memcpy(pwlanhdr->addr3, pwdinfo->p2p_peer_interface_addr, ETH_ALEN);
3339	} else {
3340	/* broadcast probe request frame */
3341	eth_broadcast_addr(pwlanhdr->addr1);
3342	eth_broadcast_addr(pwlanhdr->addr3);
3343	}
3344	}	3227	}
		3228
3345	memcpy(pwlanhdr->addr2, mac, ETH_ALEN);	3229	memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
3346		3230
3347	SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);	3231	SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
@@ -3567,23 +3451,10 @@ static int _issue_probereq_p2p(struct adapter padapter, u8 da, int wait_ack) · 219 unmodified lines
3567		3451
3568	pattrib->last_txcmdsz = pattrib->pktlen;	3452	pattrib->last_txcmdsz = pattrib->pktlen;
3569		3453
3570	if (wait_ack) {	3454	dump_mgntframe(padapter, pmgntframe);
3571	ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
3572	} else {
3573	dump_mgntframe(padapter, pmgntframe);
3574	ret = _SUCCESS;
3575	}
3576
3577	exit:
3578	return ret;
3579	}
3580
3581	inline void issue_probereq_p2p(struct adapter adapter, u8 da)
3582	{
3583	_issue_probereq_p2p(adapter, da, false);
3584	}	3455	}
3585		3456
3586	static s32 rtw_action_public_decache(struct recv_frame *recv_frame, s32 token)	3457	static s32 rtw_action_public_decache(struct recv_frame *recv_frame, u8 token)
3587	{	3458	{
3588	struct adapter *adapter = recv_frame->adapter;	3459	struct adapter *adapter = recv_frame->adapter;
3589	struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;	3460	struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
@@ -3592,21 +3463,13 @@ static s32 rtw_action_public_decache(struct recv_frame *recv_frame, s32 token) · 2 unmodified lines
3592	(recv_frame->attrib.frag_num & 0xf);	3463	(recv_frame->attrib.frag_num & 0xf);
3593		3464
3594	if (GetRetry(frame)) {	3465	if (GetRetry(frame)) {
3595	if (token >= 0) {	3466	if ((seq_ctrl == mlmeext->action_public_rxseq) &&
3596	if ((seq_ctrl == mlmeext->action_public_rxseq) &&	3467	(token == mlmeext->action_public_dialog_token))
3597	(token == mlmeext->action_public_dialog_token))	3468	return _FAIL;
3598	return _FAIL;
3599	} else {
3600	if (seq_ctrl == mlmeext->action_public_rxseq)
3601	return _FAIL;
3602	}
3603	}	3469	}
3604		3470
3605	mlmeext->action_public_rxseq = seq_ctrl;	3471	mlmeext->action_public_rxseq = seq_ctrl;
3606		3472	mlmeext->action_public_dialog_token = token;
3607	if (token >= 0)
3608	mlmeext->action_public_dialog_token = token;
3609
3610	return _SUCCESS;	3473	return _SUCCESS;
3611	}	3474	}
3612		3475
@@ -3872,110 +3735,64 @@ static unsigned int on_action_public_p2p(struct recv_frame *precv_frame) · 259 unmodified lines
3872	return _SUCCESS;	3735	return _SUCCESS;
3873	}	3736	}
3874		3737
3875	static unsigned int on_action_public_vendor(struct recv_frame *precv_frame)	3738	static void on_action_public_vendor(struct recv_frame *precv_frame)
3876	{	3739	{
3877	unsigned int ret = _FAIL;
3878	u8 *pframe = precv_frame->rx_data;	3740	u8 *pframe = precv_frame->rx_data;
3879	u8 *frame_body = pframe + sizeof(struct ieee80211_hdr_3addr);	3741	u8 *frame_body = pframe + sizeof(struct ieee80211_hdr_3addr);
3880		3742
3881	if (!memcmp(frame_body + 2, P2P_OUI, 4)) {	3743	if (!memcmp(frame_body + 2, P2P_OUI, 4))
3882	ret = on_action_public_p2p(precv_frame);	3744	on_action_public_p2p(precv_frame);
3883	}
3884
3885	return ret;
3886	}	3745	}
3887		3746
3888	static unsigned int on_action_public_default(struct recv_frame *precv_frame)	3747	static void on_action_public_default(struct recv_frame *precv_frame)
3889	{	3748	{
3890	unsigned int ret = _FAIL;
3891	u8 *pframe = precv_frame->rx_data;	3749	u8 *pframe = precv_frame->rx_data;
3892	u8 *frame_body = pframe + sizeof(struct ieee80211_hdr_3addr);	3750	u8 *frame_body = pframe + sizeof(struct ieee80211_hdr_3addr);
3893	u8 token;	3751	u8 token;
3894		3752
3895	token = frame_body[2];	3753	token = frame_body[2];
3896		3754
3897	if (rtw_action_public_decache(precv_frame, token) == _FAIL)	3755	rtw_action_public_decache(precv_frame, token);
3898	goto exit;
3899
3900	ret = _SUCCESS;
3901
3902	exit:
3903	return ret;
3904	}	3756	}
3905		3757
3906	unsigned int on_action_public(struct adapter padapter, struct recv_frame precv_frame)	3758	static void on_action_public(struct adapter padapter, struct recv_frame precv_frame)
3907	{	3759	{
3908	unsigned int ret = _FAIL;	3760	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;
3909	u8 *pframe = precv_frame->rx_data;
3910	u8 *frame_body = pframe + sizeof(struct ieee80211_hdr_3addr);
3911	u8 category, action;
3912
3913	/* check RA matches or not */
3914	if (memcmp(myid(&padapter->eeprompriv), GetAddr1Ptr(pframe), ETH_ALEN))
3915	goto exit;
3916
3917	category = frame_body[0];
3918	if (category != WLAN_CATEGORY_PUBLIC)
3919	goto exit;
3920
3921	action = frame_body[1];
3922	switch (action) {
3923	case ACT_PUBLIC_VENDOR:
3924	ret = on_action_public_vendor(precv_frame);
3925	break;
3926	default:
3927	ret = on_action_public_default(precv_frame);
3928	break;
3929	}
3930		3761
3931	exit:	3762	/* All members of the action enum start with action_code. */
3932	return ret;	3763	if (mgmt->u.action.u.s1g.action_code == WLAN_PUB_ACTION_VENDOR_SPECIFIC)
		3764	on_action_public_vendor(precv_frame);
		3765	else
		3766	on_action_public_default(precv_frame);
3933	}	3767	}
3934		3768
3935	unsigned int OnAction_p2p(struct adapter padapter, struct recv_frame precv_frame)	3769	static void OnAction_p2p(struct adapter padapter, struct recv_frame precv_frame)
3936	{	3770	{
3937	u8 *frame_body;	3771	u8 *frame_body;
3938	u8 category, OUI_Subtype;	3772	u8 OUI_Subtype;
3939	u8 *pframe = precv_frame->rx_data;	3773	u8 *pframe = precv_frame->rx_data;
3940	uint len = precv_frame->len;	3774	uint len = precv_frame->len;
3941	struct wifidirect_info *pwdinfo = &padapter->wdinfo;	3775	struct wifidirect_info *pwdinfo = &padapter->wdinfo;
3942		3776
3943	/* check RA matches or not */
3944	if (memcmp(myid(&padapter->eeprompriv), GetAddr1Ptr(pframe), ETH_ALEN))/* for if1, sta/ap mode */
3945	return _SUCCESS;
3946
3947	frame_body = (unsigned char *)(pframe + sizeof(struct ieee80211_hdr_3addr));	3777	frame_body = (unsigned char *)(pframe + sizeof(struct ieee80211_hdr_3addr));
3948		3778
3949	category = frame_body[0];
3950	if (category != RTW_WLAN_CATEGORY_P2P)
3951	return _SUCCESS;
3952
3953	if (be32_to_cpu(((__be32 )(frame_body + 1))) != P2POUI)	3779	if (be32_to_cpu(((__be32 )(frame_body + 1))) != P2POUI)
3954	return _SUCCESS;	3780	return;
3955		3781
3956	len -= sizeof(struct ieee80211_hdr_3addr);	3782	len -= sizeof(struct ieee80211_hdr_3addr);
3957	OUI_Subtype = frame_body[5];	3783	OUI_Subtype = frame_body[5];
3958		3784
3959	switch (OUI_Subtype) {	3785	if (OUI_Subtype == P2P_PRESENCE_REQUEST)
3960	case P2P_NOTICE_OF_ABSENCE:
3961	break;
3962	case P2P_PRESENCE_REQUEST:
3963	process_p2p_presence_req(pwdinfo, pframe, len);	3786	process_p2p_presence_req(pwdinfo, pframe, len);
3964	break;
3965	case P2P_PRESENCE_RESPONSE:
3966	break;
3967	case P2P_GO_DISC_REQUEST:
3968	break;
3969	default:
3970	break;
3971	}
3972	return _SUCCESS;
3973	}	3787	}
3974		3788
3975	unsigned int OnAction(struct adapter padapter, struct recv_frame precv_frame)	3789	static void OnAction(struct adapter padapter, struct recv_frame precv_frame)
3976	{	3790	{
3977	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;	3791	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;
3978		3792
		3793	if (!ether_addr_equal(myid(&padapter->eeprompriv), mgmt->da))
		3794	return;
		3795
3979	switch (mgmt->u.action.category) {	3796	switch (mgmt->u.action.category) {
3980	case WLAN_CATEGORY_BACK:	3797	case WLAN_CATEGORY_BACK:
3981	OnAction_back(padapter, precv_frame);	3798	OnAction_back(padapter, precv_frame);
@@ -3987,7 +3804,6 @@ unsigned int OnAction(struct adapter padapter, struct recv_frame precv_frame) · 5 unmodified lines
3987	OnAction_p2p(padapter, precv_frame);	3804	OnAction_p2p(padapter, precv_frame);
3988	break;	3805	break;
3989	}	3806	}
3990	return _SUCCESS;
3991	}	3807	}
3992		3808
3993	struct xmit_frame alloc_mgtxmitframe(struct xmit_priv pxmitpriv)	3809	struct xmit_frame alloc_mgtxmitframe(struct xmit_priv pxmitpriv)
@@ -4011,9 +3827,66 @@ struct xmit_frame alloc_mgtxmitframe(struct xmit_priv pxmitpriv) · 17 unmodified lines
4011	return pmgntframe;	3827	return pmgntframe;
4012	}	3828	}
4013		3829
		3830	void mgt_dispatcher(struct adapter padapter, struct recv_frame precv_frame)
		3831	{
		3832	mlme_handler mlme_sta_tbl[] = {
		3833	OnAssocReq,
		3834	OnAssocRsp,
		3835	OnAssocReq,
		3836	OnAssocRsp,
		3837	OnProbeReq,
		3838	OnProbeRsp,
		3839	NULL,
		3840	NULL,
		3841	OnBeacon,
		3842	NULL,
		3843	OnDisassoc,
		3844	OnAuthClient,
		3845	OnDeAuth,
		3846	OnAction,
		3847	};
		3848	int index;
		3849	mlme_handler fct;
		3850	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
		3851	struct ieee80211_hdr hdr = (struct ieee80211_hdr )precv_frame->rx_data;
		3852	struct sta_info *psta = rtw_get_stainfo(&padapter->stapriv, hdr->addr2);
		3853
		3854	if (!ieee80211_is_mgmt(hdr->frame_control))
		3855	return;
		3856
		3857	/* receive the frames that ra(a1) is my address or ra(a1) is bc address. */
		3858	if (memcmp(hdr->addr1, myid(&padapter->eeprompriv), ETH_ALEN) &&
		3859	!is_broadcast_ether_addr(hdr->addr1))
		3860	return;
		3861
		3862	index = (le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_STYPE) >> 4;
		3863	if (index >= ARRAY_SIZE(mlme_sta_tbl))
		3864	return;
		3865	fct = mlme_sta_tbl[index];
		3866
		3867	if (psta) {
		3868	if (ieee80211_has_retry(hdr->frame_control)) {
		3869	if (precv_frame->attrib.seq_num == psta->RxMgmtFrameSeqNum)
		3870	/* drop the duplicate management frame */
		3871	return;
		3872	}
		3873	psta->RxMgmtFrameSeqNum = precv_frame->attrib.seq_num;
		3874	}
		3875
		3876	if (ieee80211_is_auth(hdr->frame_control)) {
		3877	if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
		3878	fct = OnAuth;
		3879	else
		3880	fct = OnAuthClient;
		3881	}
		3882
		3883	if (fct)
		3884	fct(padapter, precv_frame);
		3885	}
		3886
4014	/****************************************************************************	3887	/****************************************************************************
4015		3888
4016	Following are some TX fuctions for WiFi MLME	3889	Following are some TX functions for WiFi MLME
4017		3890
4018	*****************************************************************************/	3891	*****************************************************************************/
4019		3892
@@ -4059,9 +3932,6 @@ void update_mgntframe_attrib(struct adapter padapter, struct pkt_attrib pattri · 39 unmodified lines
4059		3932
4060	void dump_mgntframe(struct adapter padapter, struct xmit_frame pmgntframe)	3933	void dump_mgntframe(struct adapter padapter, struct xmit_frame pmgntframe)
4061	{	3934	{
4062	if (padapter->bSurpriseRemoved \|\| padapter->bDriverStopped)
4063	return;
4064
4065	rtl8188eu_mgnt_xmit(padapter, pmgntframe);	3935	rtl8188eu_mgnt_xmit(padapter, pmgntframe);
4066	}	3936	}
4067		3937
@@ -4091,9 +3961,6 @@ s32 dump_mgntframe_and_wait_ack(struct adapter padapter, struct xmit_frame pmg · 23 unmodified lines
4091	u32 timeout_ms = 500;/* 500ms */	3961	u32 timeout_ms = 500;/* 500ms */
4092	struct xmit_priv *pxmitpriv = &padapter->xmitpriv;	3962	struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
4093		3963
4094	if (padapter->bSurpriseRemoved \|\| padapter->bDriverStopped)
4095	return -1;
4096
4097	mutex_lock(&pxmitpriv->ack_tx_mutex);	3964	mutex_lock(&pxmitpriv->ack_tx_mutex);
4098	pxmitpriv->ack_tx = true;	3965	pxmitpriv->ack_tx = true;
4099		3966
@@ -4588,34 +4455,19 @@ inline void issue_probereq(struct adapter padapter, struct ndis_802_11_ssid ps · 488 unmodified lines
4588	_issue_probereq(padapter, pssid, da, false);	4455	_issue_probereq(padapter, pssid, da, false);
4589	}	4456	}
4590		4457
4591	int issue_probereq_ex(struct adapter padapter, struct ndis_802_11_ssid pssid, u8 *da,	4458	void issue_probereq_ex(struct adapter padapter, struct ndis_802_11_ssid pssid, u8 *da)
4592	int try_cnt, int wait_ms)
4593	{	4459	{
4594	int ret;	4460	int i;
4595	int i = 0;
4596
4597	do {
4598	ret = _issue_probereq(padapter, pssid, da, wait_ms > 0);
4599
4600	i++;
4601		4461
4602	if (padapter->bDriverStopped \|\| padapter->bSurpriseRemoved)	4462	for (i = 0; i < 3; i++) {
		4463	if (_issue_probereq(padapter, pssid, da, true) == _FAIL)
		4464	msleep(1);
		4465	else
4603	break;	4466	break;
4604
4605	if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
4606	msleep(wait_ms);
4607
4608	} while ((i < try_cnt) && ((ret == _FAIL) \|\| (wait_ms == 0)));
4609
4610	if (ret != _FAIL) {
4611	ret = _SUCCESS;
4612	goto exit;
4613	}	4467	}
4614	exit:
4615	return ret;
4616	}	4468	}
4617		4469
4618	/* if psta == NULL, indiate we are station(client) now... */	4470	/* if psta == NULL, indicate we are station (client) now... */
4619	void issue_auth(struct adapter padapter, struct sta_info psta, unsigned short status)	4471	void issue_auth(struct adapter padapter, struct sta_info psta, unsigned short status)
4620	{	4472	{
4621	struct xmit_frame *pmgntframe;	4473	struct xmit_frame *pmgntframe;
@@ -5014,7 +4866,7 @@ void issue_assocreq(struct adapter *padapter) · 392 unmodified lines
5014	if (!padapter->registrypriv.wifi_spec) {	4866	if (!padapter->registrypriv.wifi_spec) {
5015	/* Commented by Kurt 20110629 */	4867	/* Commented by Kurt 20110629 */
5016	/* In some older APs, WPS handshake */	4868	/* In some older APs, WPS handshake */
5017	/* would be fail if we append vender extensions informations to AP */	4869	/* would be fail if we append vendor extension information to AP */
5018	if (!memcmp(pIE->data, WPS_OUI, 4))	4870	if (!memcmp(pIE->data, WPS_OUI, 4))
5019	pIE->Length = 14;	4871	pIE->Length = 14;
5020	}	4872	}
@@ -5169,7 +5021,7 @@ exit: · 148 unmodified lines
5169	kfree(pmlmepriv->assoc_req);	5021	kfree(pmlmepriv->assoc_req);
5170	}	5022	}
5171		5023
5172	/* when wait_ack is ture, this function shoule be called at process context */	5024	/* when wait_ack is true, this function should be called at process context */
5173	static int _issue_nulldata(struct adapter padapter, unsigned char da, unsigned int power_mode, int wait_ack)	5025	static int _issue_nulldata(struct adapter padapter, unsigned char da, unsigned int power_mode, int wait_ack)
5174	{	5026	{
5175	int ret = _FAIL;	5027	int ret = _FAIL;
@@ -5238,7 +5090,7 @@ exit: · 62 unmodified lines
5238	return ret;	5090	return ret;
5239	}	5091	}
5240		5092
5241	/* when wait_ms > 0 , this function shoule be called at process context */	5093	/* when wait_ms > 0, this function should be called at process context */
5242	/* da == NULL for station mode */	5094	/* da == NULL for station mode */
5243	int issue_nulldata(struct adapter padapter, unsigned char da, unsigned int power_mode, int try_cnt, int wait_ms)	5095	int issue_nulldata(struct adapter padapter, unsigned char da, unsigned int power_mode, int try_cnt, int wait_ms)
5244	{	5096	{
@@ -5247,7 +5099,7 @@ int issue_nulldata(struct adapter padapter, unsigned char da, unsigned int pow · 2 unmodified lines
5247	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	5099	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5248	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;	5100	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
5249		5101
5250	/* da == NULL, assum it's null data for sta to ap*/	5102	/* da == NULL, assume it's null data for sta to ap*/
5251	if (!da)	5103	if (!da)
5252	da = get_my_bssid(&pmlmeinfo->network);	5104	da = get_my_bssid(&pmlmeinfo->network);
5253		5105
@@ -5271,7 +5123,7 @@ exit: · 17 unmodified lines
5271	return ret;	5123	return ret;
5272	}	5124	}
5273		5125
5274	/* when wait_ack is ture, this function shoule be called at process context */	5126	/* when wait_ack is true, this function should be called at process context */
5275	static int _issue_qos_nulldata(struct adapter padapter, unsigned char da, u16 tid, int wait_ack)	5127	static int _issue_qos_nulldata(struct adapter padapter, unsigned char da, u16 tid, int wait_ack)
5276	{	5128	{
5277	int ret = _FAIL;	5129	int ret = _FAIL;
@@ -5344,7 +5196,7 @@ exit: · 66 unmodified lines
5344	return ret;	5196	return ret;
5345	}	5197	}
5346		5198
5347	/* when wait_ms > 0 , this function shoule be called at process context */	5199	/* when wait_ms > 0 , this function should be called at process context */
5348	/* da == NULL for station mode */	5200	/* da == NULL for station mode */
5349	int issue_qos_nulldata(struct adapter padapter, unsigned char da, u16 tid, int try_cnt, int wait_ms)	5201	int issue_qos_nulldata(struct adapter padapter, unsigned char da, u16 tid, int try_cnt, int wait_ms)
5350	{	5202	{
@@ -5353,7 +5205,7 @@ int issue_qos_nulldata(struct adapter padapter, unsigned char da, u16 tid, int · 2 unmodified lines
5353	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	5205	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5354	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;	5206	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
5355		5207
5356	/* da == NULL, assum it's null data for sta to ap*/	5208	/* da == NULL, assume it's null data for sta to ap*/
5357	if (!da)	5209	if (!da)
5358	da = get_my_bssid(&pmlmeinfo->network);	5210	da = get_my_bssid(&pmlmeinfo->network);
5359		5211
@@ -5471,7 +5323,8 @@ exit: · 111 unmodified lines
5471	return ret;	5323	return ret;
5472	}	5324	}
5473		5325
5474	void issue_action_BA(struct adapter padapter, unsigned char raddr, u8 action, u16 status)	5326	void issue_action_BA(struct adapter padapter, unsigned char raddr, u8 action,
		5327	u16 status, struct ieee80211_mgmt *mgmt_req)
5475	{	5328	{
5476	u16 start_seq;	5329	u16 start_seq;
5477	u16 BA_starting_seqctrl = 0;	5330	u16 BA_starting_seqctrl = 0;
@@ -5540,13 +5393,13 @@ void issue_action_BA(struct adapter padapter, unsigned char raddr, u8 action, · 62 unmodified lines
5540	break;	5393	break;
5541	case WLAN_ACTION_ADDBA_RESP:	5394	case WLAN_ACTION_ADDBA_RESP:
5542	mgmt->u.action.u.addba_resp.action_code = WLAN_ACTION_ADDBA_RESP;	5395	mgmt->u.action.u.addba_resp.action_code = WLAN_ACTION_ADDBA_RESP;
5543	mgmt->u.action.u.addba_resp.dialog_token = pmlmeinfo->ADDBA_req.dialog_token;	5396	mgmt->u.action.u.addba_resp.dialog_token = mgmt_req->u.action.u.addba_req.dialog_token;
5544	mgmt->u.action.u.addba_resp.status = cpu_to_le16(status);	5397	mgmt->u.action.u.addba_resp.status = cpu_to_le16(status);
5545	capab = le16_to_cpu(pmlmeinfo->ADDBA_req.BA_para_set) & 0x3f;	5398	capab = le16_to_cpu(mgmt_req->u.action.u.addba_req.capab) & 0x3f;
5546	capab \|= u16_encode_bits(64, IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK);	5399	capab \|= u16_encode_bits(64, IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK);
5547	capab \|= u16_encode_bits(pregpriv->ampdu_amsdu, IEEE80211_ADDBA_PARAM_AMSDU_MASK);	5400	capab \|= u16_encode_bits(pregpriv->ampdu_amsdu, IEEE80211_ADDBA_PARAM_AMSDU_MASK);
5548	mgmt->u.action.u.addba_req.capab = cpu_to_le16(capab);	5401	mgmt->u.action.u.addba_req.capab = cpu_to_le16(capab);
5549	mgmt->u.action.u.addba_resp.timeout = pmlmeinfo->ADDBA_req.BA_timeout_value;	5402	mgmt->u.action.u.addba_resp.timeout = mgmt_req->u.action.u.addba_req.timeout;
5550	pattrib->pktlen = offsetofend(struct ieee80211_mgmt, u.action.u.addba_resp.timeout);	5403	pattrib->pktlen = offsetofend(struct ieee80211_mgmt, u.action.u.addba_resp.timeout);
5551	break;	5404	break;
5552	case WLAN_ACTION_DELBA:	5405	case WLAN_ACTION_DELBA:
@@ -5714,7 +5567,8 @@ unsigned int send_delba(struct adapter padapter, u8 initiator, u8 addr) · 161 unmodified lines
5714	if (initiator == 0) { /* recipient */	5567	if (initiator == 0) { /* recipient */
5715	for (tid = 0; tid < MAXTID; tid++) {	5568	for (tid = 0; tid < MAXTID; tid++) {
5716	if (psta->recvreorder_ctrl[tid].enable) {	5569	if (psta->recvreorder_ctrl[tid].enable) {
5717	issue_action_BA(padapter, addr, WLAN_ACTION_DELBA, (((tid << 1) \| initiator) & 0x1F));	5570	issue_action_BA(padapter, addr, WLAN_ACTION_DELBA,
		5571	(((tid << 1) \| initiator) & 0x1F), NULL);
5718	psta->recvreorder_ctrl[tid].enable = false;	5572	psta->recvreorder_ctrl[tid].enable = false;
5719	psta->recvreorder_ctrl[tid].indicate_seq = 0xffff;	5573	psta->recvreorder_ctrl[tid].indicate_seq = 0xffff;
5720	}	5574	}
@@ -5722,7 +5576,8 @@ unsigned int send_delba(struct adapter padapter, u8 initiator, u8 addr) · 1 unmodified line
5722	} else if (initiator == 1) { /* originator */	5576	} else if (initiator == 1) { /* originator */
5723	for (tid = 0; tid < MAXTID; tid++) {	5577	for (tid = 0; tid < MAXTID; tid++) {
5724	if (psta->htpriv.agg_enable_bitmap & BIT(tid)) {	5578	if (psta->htpriv.agg_enable_bitmap & BIT(tid)) {
5725	issue_action_BA(padapter, addr, WLAN_ACTION_DELBA, (((tid << 1) \| initiator) & 0x1F));	5579	issue_action_BA(padapter, addr, WLAN_ACTION_DELBA,
		5580	(((tid << 1) \| initiator) & 0x1F), NULL);
5726	psta->htpriv.agg_enable_bitmap &= ~BIT(tid);	5581	psta->htpriv.agg_enable_bitmap &= ~BIT(tid);
5727	psta->htpriv.candidate_tid_bitmap &= ~BIT(tid);	5582	psta->htpriv.candidate_tid_bitmap &= ~BIT(tid);
5728	}	5583	}
@@ -5885,7 +5740,7 @@ static void rtw_set_opmode(struct adapter *adapter, u8 mode) · 156 unmodified lines
5885		5740
5886	/****************************************************************************	5741	/****************************************************************************
5887		5742
5888	Following are some utitity fuctions for WiFi MLME	5743	Following are some utility functions for WiFi MLME
5889		5744
5890	*****************************************************************************/	5745	*****************************************************************************/
5891		5746
@@ -5937,7 +5792,7 @@ void rtw_mlme_site_survey_done(struct adapter *adapter) · 45 unmodified lines
5937	int res;	5792	int res;
5938	u8 reg;	5793	u8 reg;
5939		5794
5940	if ((is_client_associated_to_ap(adapter)) \|\|	5795	if ((r8188eu_is_client_associated_to_ap(adapter)) \|\|
5941	((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE)) {	5796	((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE)) {
5942	/* enable to rx data frame */	5797	/* enable to rx data frame */
5943	rtw_write16(adapter, REG_RXFLTMAP2, 0xFFFF);	5798	rtw_write16(adapter, REG_RXFLTMAP2, 0xFFFF);
@@ -6008,9 +5863,9 @@ void site_survey(struct adapter *padapter) · 64 unmodified lines
6008	if (ScanType == SCAN_ACTIVE) { /* obey the channel plan setting... */	5863	if (ScanType == SCAN_ACTIVE) { /* obey the channel plan setting... */
6009	if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_SCAN) \|\|	5864	if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_SCAN) \|\|
6010	rtw_p2p_chk_state(pwdinfo, P2P_STATE_FIND_PHASE_SEARCH)) {	5865	rtw_p2p_chk_state(pwdinfo, P2P_STATE_FIND_PHASE_SEARCH)) {
6011	issue_probereq_p2p(padapter, NULL);	5866	issue_probereq_p2p(padapter);
6012	issue_probereq_p2p(padapter, NULL);	5867	issue_probereq_p2p(padapter);
6013	issue_probereq_p2p(padapter, NULL);	5868	issue_probereq_p2p(padapter);
6014	} else {	5869	} else {
6015	int i;	5870	int i;
6016	for (i = 0; i < RTW_SSID_SCAN_AMOUNT; i++) {	5871	for (i = 0; i < RTW_SSID_SCAN_AMOUNT; i++) {
@@ -6058,7 +5913,7 @@ void site_survey(struct adapter *padapter) · 41 unmodified lines
6058	} else {	5913	} else {
6059	/* 20100721:Interrupt scan operation here. */	5914	/* 20100721:Interrupt scan operation here. */
6060	/* For SW antenna diversity before link, it needs to switch to another antenna and scan again. */	5915	/* For SW antenna diversity before link, it needs to switch to another antenna and scan again. */
6061	/* It compares the scan result and select beter one to do connection. */	5916	/* It compares the scan result and selects a better one to do connection. */
6062	if (AntDivBeforeLink8188E(padapter)) {	5917	if (AntDivBeforeLink8188E(padapter)) {
6063	pmlmeext->sitesurvey_res.bss_cnt = 0;	5918	pmlmeext->sitesurvey_res.bss_cnt = 0;
6064	pmlmeext->sitesurvey_res.channel_idx = -1;	5919	pmlmeext->sitesurvey_res.channel_idx = -1;
@@ -6088,7 +5943,7 @@ void site_survey(struct adapter *padapter) · 23 unmodified lines
6088	Restore_DM_Func_Flag(padapter);	5943	Restore_DM_Func_Flag(padapter);
6089	/* Switch_DM_Func(padapter, DYNAMIC_ALL_FUNC_ENABLE, true); */	5944	/* Switch_DM_Func(padapter, DYNAMIC_ALL_FUNC_ENABLE, true); */
6090		5945
6091	if (is_client_associated_to_ap(padapter))	5946	if (r8188eu_is_client_associated_to_ap(padapter))
6092	issue_nulldata(padapter, NULL, 0, 3, 500);	5947	issue_nulldata(padapter, NULL, 0, 3, 500);
6093		5948
6094	rtw_mlme_site_survey_done(padapter);	5949	rtw_mlme_site_survey_done(padapter);
@@ -6108,10 +5963,11 @@ void site_survey(struct adapter *padapter) · 13 unmodified lines
6108	/* collect bss info from Beacon and Probe request/response frames. */	5963	/* collect bss info from Beacon and Probe request/response frames. */
6109	u8 collect_bss_info(struct adapter padapter, struct recv_frame precv_frame, struct wlan_bssid_ex *bssid)	5964	u8 collect_bss_info(struct adapter padapter, struct recv_frame precv_frame, struct wlan_bssid_ex *bssid)
6110	{	5965	{
		5966	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )precv_frame->rx_data;
6111	int i;	5967	int i;
6112	u32 len;	5968	u32 len;
6113	u8 *p;	5969	u8 *p;
6114	u16 val16, subtype;	5970	u16 val16;
6115	u8 *pframe = precv_frame->rx_data;	5971	u8 *pframe = precv_frame->rx_data;
6116	u32 packet_len = precv_frame->len;	5972	u32 packet_len = precv_frame->len;
6117	u8 ie_offset;	5973	u8 ie_offset;
@@ -6127,23 +5983,18 @@ u8 collect_bss_info(struct adapter padapter, struct recv_frame precv_frame, st · 9 unmodified lines
6127		5983
6128	memset(bssid, 0, sizeof(struct wlan_bssid_ex));	5984	memset(bssid, 0, sizeof(struct wlan_bssid_ex));
6129		5985
6130	subtype = GetFrameSubType(pframe);	5986	if (ieee80211_is_beacon(mgmt->frame_control)) {
6131
6132	if (subtype == WIFI_BEACON) {
6133	bssid->Reserved[0] = 1;	5987	bssid->Reserved[0] = 1;
6134	ie_offset = _BEACON_IE_OFFSET_;	5988	ie_offset = _BEACON_IE_OFFSET_;
		5989	} else if (ieee80211_is_probe_req(mgmt->frame_control)) {
		5990	ie_offset = _PROBEREQ_IE_OFFSET_;
		5991	bssid->Reserved[0] = 2;
		5992	} else if (ieee80211_is_probe_resp(mgmt->frame_control)) {
		5993	ie_offset = _PROBERSP_IE_OFFSET_;
		5994	bssid->Reserved[0] = 3;
6135	} else {	5995	} else {
6136	/* FIXME : more type */	5996	bssid->Reserved[0] = 0;
6137	if (subtype == WIFI_PROBEREQ) {	5997	ie_offset = _FIXED_IE_LENGTH_;
6138	ie_offset = _PROBEREQ_IE_OFFSET_;
6139	bssid->Reserved[0] = 2;
6140	} else if (subtype == WIFI_PROBERSP) {
6141	ie_offset = _PROBERSP_IE_OFFSET_;
6142	bssid->Reserved[0] = 3;
6143	} else {
6144	bssid->Reserved[0] = 0;
6145	ie_offset = _FIXED_IE_LENGTH_;
6146	}
6147	}	5998	}
6148		5999
6149	bssid->Length = sizeof(struct wlan_bssid_ex) - MAX_IE_SZ + len;	6000	bssid->Length = sizeof(struct wlan_bssid_ex) - MAX_IE_SZ + len;
@@ -6191,9 +6042,6 @@ u8 collect_bss_info(struct adapter padapter, struct recv_frame precv_frame, st · 41 unmodified lines
6191	memcpy(bssid->SupportedRates + i, (p + 2), len);	6042	memcpy(bssid->SupportedRates + i, (p + 2), len);
6192	}	6043	}
6193		6044
6194	/* todo: */
6195	bssid->NetworkTypeInUse = Ndis802_11OFDM24;
6196
6197	if (bssid->IELength < 12)	6045	if (bssid->IELength < 12)
6198	return _FAIL;	6046	return _FAIL;
6199		6047
@@ -6328,7 +6176,7 @@ void start_create_ibss(struct adapter *padapter) · 128 unmodified lines
6328	/* update wireless mode */	6176	/* update wireless mode */
6329	update_wireless_mode(padapter);	6177	update_wireless_mode(padapter);
6330		6178
6331	/* udpate capability */	6179	/* update capability */
6332	caps = rtw_get_capability((struct wlan_bssid_ex *)pnetwork);	6180	caps = rtw_get_capability((struct wlan_bssid_ex *)pnetwork);
6333	update_capinfo(padapter, caps);	6181	update_capinfo(padapter, caps);
6334	if (caps & cap_IBSS) {/* adhoc master */	6182	if (caps & cap_IBSS) {/* adhoc master */
@@ -6378,7 +6226,7 @@ void start_clnt_join(struct adapter *padapter) · 43 unmodified lines
6378	/* update wireless mode */	6226	/* update wireless mode */
6379	update_wireless_mode(padapter);	6227	update_wireless_mode(padapter);
6380		6228
6381	/* udpate capability */	6229	/* update capability */
6382	caps = rtw_get_capability((struct wlan_bssid_ex *)pnetwork);	6230	caps = rtw_get_capability((struct wlan_bssid_ex *)pnetwork);
6383	update_capinfo(padapter, caps);	6231	update_capinfo(padapter, caps);
6384	if (caps & cap_ESS) {	6232	if (caps & cap_ESS) {
@@ -6756,9 +6604,6 @@ void report_join_res(struct adapter *padapter, int res) · 371 unmodified lines
6756	pcmd_obj->cmdsz = cmdsz;	6604	pcmd_obj->cmdsz = cmdsz;
6757	pcmd_obj->parmbuf = pevtcmd;	6605	pcmd_obj->parmbuf = pevtcmd;
6758		6606
6759	pcmd_obj->rsp = NULL;
6760	pcmd_obj->rspsz = 0;
6761
6762	pc2h_evt_hdr = (struct C2HEvent_Header *)(pevtcmd);	6607	pc2h_evt_hdr = (struct C2HEvent_Header *)(pevtcmd);
6763	pc2h_evt_hdr->len = sizeof(struct joinbss_event);	6608	pc2h_evt_hdr->len = sizeof(struct joinbss_event);
6764	pc2h_evt_hdr->ID = GEN_EVT_CODE(_JoinBss);	6609	pc2h_evt_hdr->ID = GEN_EVT_CODE(_JoinBss);
@@ -6972,7 +6817,7 @@ void mlmeext_joinbss_event_callback(struct adapter *padapter, int join_res) · 207 unmodified lines
6972	/* BCN interval */	6817	/* BCN interval */
6973	rtw_write16(padapter, REG_BCN_INTERVAL, pmlmeinfo->bcn_interval);	6818	rtw_write16(padapter, REG_BCN_INTERVAL, pmlmeinfo->bcn_interval);
6974		6819
6975	/* udpate capability */	6820	/* update capability */
6976	update_capinfo(padapter, pmlmeinfo->capability);	6821	update_capinfo(padapter, pmlmeinfo->capability);
6977		6822
6978	/* WMM, Update EDCA param */	6823	/* WMM, Update EDCA param */
@@ -7064,7 +6909,7 @@ void mlmeext_sta_del_event_callback(struct adapter *padapter) · 85 unmodified lines
7064	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	6909	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
7065	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;	6910	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
7066		6911
7067	if (is_client_associated_to_ap(padapter) \|\| is_IBSS_empty(padapter)) {	6912	if (r8188eu_is_client_associated_to_ap(padapter) \|\| r8188eu_is_ibss_empty(padapter)) {
7068	mlme_disconnect(padapter);	6913	mlme_disconnect(padapter);
7069	rtw_set_bssid(padapter, null_addr);	6914	rtw_set_bssid(padapter, null_addr);
7070		6915
@@ -7137,7 +6982,7 @@ void linked_status_chk(struct adapter *padapter) · 66 unmodified lines
7137		6982
7138	rtl8188e_sreset_linked_status_check(padapter);	6983	rtl8188e_sreset_linked_status_check(padapter);
7139		6984
7140	if (is_client_associated_to_ap(padapter)) {	6985	if (r8188eu_is_client_associated_to_ap(padapter)) {
7141	/* linked infrastructure client mode */	6986	/* linked infrastructure client mode */
7142		6987
7143	int tx_chk = _SUCCESS, rx_chk = _SUCCESS;	6988	int tx_chk = _SUCCESS, rx_chk = _SUCCESS;
@@ -7165,7 +7010,7 @@ void linked_status_chk(struct adapter *padapter) · 21 unmodified lines
7165	}	7010	}
7166		7011
7167	if (rx_chk != _SUCCESS)	7012	if (rx_chk != _SUCCESS)
7168	issue_probereq_ex(padapter, &pmlmeinfo->network.Ssid, psta->hwaddr, 3, 1);	7013	issue_probereq_ex(padapter, &pmlmeinfo->network.Ssid, psta->hwaddr);
7169		7014
7170	if ((tx_chk != _SUCCESS && pmlmeinfo->link_count++ == 0xf) \|\| rx_chk != _SUCCESS) {	7015	if ((tx_chk != _SUCCESS && pmlmeinfo->link_count++ == 0xf) \|\| rx_chk != _SUCCESS) {
7171	tx_chk = issue_nulldata(padapter, psta->hwaddr, 0, 3, 1);	7016	tx_chk = issue_nulldata(padapter, psta->hwaddr, 0, 3, 1);
@@ -7209,7 +7054,7 @@ void linked_status_chk(struct adapter *padapter) · 37 unmodified lines
7209	pmlmeinfo->link_count = 0;	7054	pmlmeinfo->link_count = 0;
7210	}	7055	}
7211	} /* end of if ((psta = rtw_get_stainfo(pstapriv, passoc_res->network.MacAddress)) != NULL) */	7056	} /* end of if ((psta = rtw_get_stainfo(pstapriv, passoc_res->network.MacAddress)) != NULL) */
7212	} else if (is_client_associated_to_ibss(padapter)) {	7057	} else if (r8188eu_is_client_associated_to_ibss(padapter)) {
7213	/* linked IBSS mode */	7058	/* linked IBSS mode */
7214	/* for each assoc list entry to check the rx pkt counter */	7059	/* for each assoc list entry to check the rx pkt counter */
7215	for (i = IBSS_START_MAC_ID; i < NUM_STA; i++) {	7060	for (i = IBSS_START_MAC_ID; i < NUM_STA; i++) {
@@ -7527,7 +7372,7 @@ u8 disconnect_hdl(struct adapter padapter, unsigned char pbuf) · 311 unmodified lines
7527	u8 val8;	7372	u8 val8;
7528	int res;	7373	int res;
7529		7374
7530	if (is_client_associated_to_ap(padapter))	7375	if (r8188eu_is_client_associated_to_ap(padapter))
7531	issue_deauth_ex(padapter, pnetwork->MacAddress, WLAN_REASON_DEAUTH_LEAVING, param->deauth_timeout_ms / 100, 100);	7376	issue_deauth_ex(padapter, pnetwork->MacAddress, WLAN_REASON_DEAUTH_LEAVING, param->deauth_timeout_ms / 100, 100);
7532		7377
7533	mlme_disconnect(padapter);	7378	mlme_disconnect(padapter);
@@ -7639,7 +7484,7 @@ u8 sitesurvey_cmd_hdl(struct adapter padapter, u8 pbuf) · 105 unmodified lines
7639	pmlmeext->sitesurvey_res.scan_mode = pparm->scan_mode;	7484	pmlmeext->sitesurvey_res.scan_mode = pparm->scan_mode;
7640		7485
7641	/* issue null data if associating to the AP */	7486	/* issue null data if associating to the AP */
7642	if (is_client_associated_to_ap(padapter)) {	7487	if (r8188eu_is_client_associated_to_ap(padapter)) {
7643	pmlmeext->sitesurvey_res.state = SCAN_TXNULL;	7488	pmlmeext->sitesurvey_res.state = SCAN_TXNULL;
7644		7489
7645	issue_nulldata(padapter, NULL, 1, 3, 500);	7490	issue_nulldata(padapter, NULL, 1, 3, 500);
@@ -7783,7 +7628,7 @@ u8 add_ba_hdl(struct adapter padapter, unsigned char pbuf) · 137 unmodified lines
7783		7628
7784	if (((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && (pmlmeinfo->HT_enable)) \|\|	7629	if (((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && (pmlmeinfo->HT_enable)) \|\|
7785	((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE)) {	7630	((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE)) {
7786	issue_action_BA(padapter, pparm->addr, WLAN_ACTION_ADDBA_REQ, (u16)pparm->tid);	7631	issue_action_BA(padapter, pparm->addr, WLAN_ACTION_ADDBA_REQ, (u16)pparm->tid, NULL);
7787	_set_timer(&psta->addba_retry_timer, ADDBA_TO);	7632	_set_timer(&psta->addba_retry_timer, ADDBA_TO);
7788	} else {	7633	} else {
7789	psta->htpriv.candidate_tid_bitmap &= ~BIT(pparm->tid);	7634	psta->htpriv.candidate_tid_bitmap &= ~BIT(pparm->tid);

drivers/staging/r8188eu/core/rtw_p2p.c+6−13

 	set_channel_bwmode(padapter, pwdinfo->invitereq_info.peer_ch, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
 	rtw_mlme_under_site_survey(padapter);
-	issue_probereq_p2p(padapter, NULL);
+	issue_probereq_p2p(padapter);
 	_set_timer(&pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT);
 }
 	set_channel_bwmode(padapter, pwdinfo->tx_prov_disc_info.peer_channel_num[0], HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
 	rtw_mlme_under_site_survey(padapter);
-	issue_probereq_p2p(padapter, NULL);
+	issue_probereq_p2p(padapter);
 	_set_timer(&pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT);
 }
 	set_channel_bwmode(padapter, pwdinfo->nego_req_info.peer_channel_num[0], HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
 	rtw_mlme_under_site_survey(padapter);
-	issue_probereq_p2p(padapter, NULL);
+	issue_probereq_p2p(padapter);
 	_set_timer(&pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT);
 }
 void process_p2p_ps_ie(struct adapter *padapter, u8 *IEs, u32 IELength)
 {
-	u8 *ies;
-	u32 ies_len;
 	u8 *p2p_ie;
 	u32	p2p_ielen = 0;
 	u8	noa_attr[MAX_P2P_IE_LEN] = { 0x00 };/*  NoA length should be n*(13) + 2 */
 	if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
 		return;
-	if (IELength <= _BEACON_IE_OFFSET_)
-		return;
-	ies = IEs + _BEACON_IE_OFFSET_;
+	p2p_ie = rtw_get_p2p_ie(IEs, IELength, NULL, &p2p_ielen);
-	ies_len = IELength - _BEACON_IE_OFFSET_;
-	p2p_ie = rtw_get_p2p_ie(ies, ies_len, NULL, &p2p_ielen);
 	while (p2p_ie) {
 		find_p2p = true;
 		}
 		/* Get the next P2P IE */
-		p2p_ie = rtw_get_p2p_ie(p2p_ie + p2p_ielen, ies_len - (p2p_ie - ies + p2p_ielen), NULL, &p2p_ielen);
+		p2p_ie = rtw_get_p2p_ie(p2p_ie + p2p_ielen, IELength - (p2p_ie - IEs + p2p_ielen), NULL, &p2p_ielen);
 	}
 	if (find_p2p) {
 	if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_PROVISION_DIS_REQ)) {
 		if (pwdinfo->tx_prov_disc_info.benable) {	/*	the provision discovery request frame is trigger to send or not */
 			p2p_protocol_wk_cmd(adapter, P2P_PRE_TX_PROVDISC_PROCESS_WK);
-			/* issue_probereq_p2p(adapter, NULL); */
+			/* issue_probereq_p2p(adapter); */
 			/* _set_timer(&pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT); */
 		}
 	} else if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING)) {

drivers/staging/r8188eu/core/rtw_pwrctrl.c+1−1

@@ -273,7 +273,7 @@ static s32 LPS_RF_ON_check(struct adapter *padapter, u32 delay_ms) · 272 unmodified lines
273	err = -1;	273	err = -1;
274	break;	274	break;
275	}	275	}
276	msleep(1);	276	mdelay(1);
277	}	277	}
278		278
279	return err;	279	return err;

drivers/staging/r8188eu/core/rtw_recv.c+12−15

 		}
 		/*  check BSSID */
-		if (!memcmp(pattrib->bssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) ||
+		if (is_zero_ether_addr(pattrib->bssid) || is_zero_ether_addr(mybssid) ||
-		    !memcmp(mybssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) ||
+		    (memcmp(pattrib->bssid, mybssid, ETH_ALEN))) {
-		     (memcmp(pattrib->bssid, mybssid, ETH_ALEN))) {
 			if (!bmcast)
 				issue_deauth(adapter, pattrib->bssid, WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
 			if (psta->sleepq_len == 0) {
 				pstapriv->tim_bitmap &= ~BIT(psta->aid);
-				/* upate BCN for TIM IE */
+				/* update BCN for TIM IE */
 				/* update_BCNTIM(padapter); */
 				update_beacon(padapter, _TIM_IE_, NULL, false);
 			}
 				pstapriv->tim_bitmap &= ~BIT(psta->aid);
-				/* upate BCN for TIM IE */
+				/* update BCN for TIM IE */
 				/* update_BCNTIM(padapter); */
 				update_beacon(padapter, _TIM_IE_, NULL, false);
 			}
 				    struct recv_frame *precv_frame)
 {
 	struct sta_info *psta = NULL;
-	u8 *ptr = precv_frame->rx_data;
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)precv_frame->rx_data;
 	struct rx_pkt_attrib	*pattrib = &precv_frame->attrib;
 	struct security_priv	*psecuritypriv = &adapter->securitypriv;
 	if (!psta)
 		return _FAIL;
-	/* psta->rssi = prxcmd->rssi; */
-	/* psta->signal_quality = prxcmd->sq; */
 	precv_frame->psta = psta;
 	pattrib->amsdu = 0;
 	pattrib->ack_policy = 0;
 	/* parsing QC field */
 	if (pattrib->qos) {
+		struct ieee80211_qos_hdr *qos_hdr = (struct ieee80211_qos_hdr *)hdr;
 		pattrib->priority = ieee80211_get_tid(hdr);
-		pattrib->ack_policy = GetAckpolicy((ptr + 24));
+		pattrib->ack_policy = GetAckpolicy(&qos_hdr->qos_ctrl);
-		pattrib->amsdu = GetAMsdu((ptr + 24));
+		pattrib->amsdu = GetAMsdu(&qos_hdr->qos_ctrl);
-		pattrib->hdrlen = 26;
+		pattrib->hdrlen = sizeof(*qos_hdr);
 		if (pattrib->priority != 0 && pattrib->priority != 3)
 			adapter->recvpriv.bIsAnyNonBEPkts = true;
 	struct recv_priv *precvpriv = &padapter->recvpriv;
 	struct __queue *pfree_recv_queue = &precvpriv->free_recv_queue;
-	int	ret = _SUCCESS;
 	nr_subframes = 0;
 	prframe->len = 0;
 	rtw_free_recvframe(prframe, pfree_recv_queue);/* free this recv_frame */
-	return ret;
+	return _SUCCESS;
 }
 static bool check_indicate_seq(struct recv_reorder_ctrl *preorder_ctrl, u16 seq_num)
 	} else {
 		if (recvpriv->signal_strength_data.update_req == 0) {/*  update_req is clear, means we got rx */
 			avg_signal_strength = recvpriv->signal_strength_data.avg_val;
-			/*  after avg_vals are accquired, we can re-stat the signal values */
+			/*  after avg_vals are acquired, we can re-stat the signal values */
 			recvpriv->signal_strength_data.update_req = 1;
 		}
 		if (recvpriv->signal_qual_data.update_req == 0) {/*  update_req is clear, means we got rx */
 			avg_signal_qual = recvpriv->signal_qual_data.avg_val;
-			/*  after avg_vals are accquired, we can re-stat the signal values */
+			/*  after avg_vals are acquired, we can re-stat the signal values */
 			recvpriv->signal_qual_data.update_req = 1;
 		}

drivers/staging/r8188eu/core/rtw_security.c+1−3

 }
-static int aes_cipher(u8 *key, uint hdrlen, u8 *pframe, uint plen)
+static void aes_cipher(u8 *key, uint hdrlen, u8 *pframe, uint plen)
 {
 	uint	qc_exists, a4_exists, i, j, payload_remainder,
 		num_blocks, payload_index;
 	bitwise_xor(aes_out, padded_buffer, chain_buffer);
 	for (j = 0; j < 8; j++)
 		pframe[payload_index++] = chain_buffer[j];
-	return _SUCCESS;
 }
 u32 rtw_aes_encrypt(struct adapter *padapter, struct xmit_frame *pxmitframe)

drivers/staging/r8188eu/core/rtw_sta_mgt.c+6−10

 	psta->keep_alive_trycnt = 0;
 }
-u32	_rtw_init_sta_priv(struct	sta_priv *pstapriv)
+int _rtw_init_sta_priv(struct sta_priv *pstapriv)
 {
 	struct sta_info *psta;
 	s32 i;
 	pstapriv->pallocated_stainfo_buf = vzalloc(sizeof(struct sta_info) * NUM_STA + 4);
 	if (!pstapriv->pallocated_stainfo_buf)
-		return _FAIL;
+		return -ENOMEM;
 	pstapriv->pstainfo_buf = pstapriv->pallocated_stainfo_buf + 4 -
 		((size_t)(pstapriv->pallocated_stainfo_buf) & 3);
 	pstapriv->expire_to = 3; /*  3*2 = 6 sec */
 	pstapriv->max_num_sta = NUM_STA;
-	return _SUCCESS;
+	return 0;
 }
 inline int rtw_stainfo_offset(struct sta_priv *stapriv, struct sta_info *sta)
 }
 /*  using pstapriv->sta_hash_lock to protect */
-u32	rtw_free_stainfo(struct adapter *padapter, struct sta_info *psta)
+void rtw_free_stainfo(struct adapter *padapter, struct sta_info *psta)
 {
 	int i;
 	struct __queue *pfree_sta_queue;
 	struct	sta_priv *pstapriv = &padapter->stapriv;
 	if (!psta)
-		goto exit;
+		return;
 	pfree_sta_queue = &pstapriv->free_sta_queue;
 	spin_lock_bh(&pfree_sta_queue->lock);
 	list_add_tail(&psta->list, get_list_head(pfree_sta_queue));
 	spin_unlock_bh(&pfree_sta_queue->lock);
-exit:
-	return _SUCCESS;
 }
 /*  free all stainfo which in sta_hash[all] */
 	if (!hwaddr)
 		return NULL;
-	if (IS_MCAST(hwaddr))
+	if (is_multicast_ether_addr(hwaddr))
 		addr = bc_addr;
 	else
 		addr = hwaddr;

drivers/staging/r8188eu/core/rtw_wlan_util.c+16−20

@@ -331,35 +331,35 @@ u16 get_beacon_interval(struct wlan_bssid_ex *bss) · 330 unmodified lines
331	return le16_to_cpu(val);	331	return le16_to_cpu(val);
332	}	332	}
333		333
334	int is_client_associated_to_ap(struct adapter *padapter)	334	bool r8188eu_is_client_associated_to_ap(struct adapter *padapter)
335	{	335	{
336	struct mlme_ext_priv *pmlmeext;	336	struct mlme_ext_priv *pmlmeext;
337	struct mlme_ext_info *pmlmeinfo;	337	struct mlme_ext_info *pmlmeinfo;
338		338
339	if (!padapter)	339	if (!padapter)
340	return _FAIL;	340	return false;
341		341
342	pmlmeext = &padapter->mlmeextpriv;	342	pmlmeext = &padapter->mlmeextpriv;
343	pmlmeinfo = &pmlmeext->mlmext_info;	343	pmlmeinfo = &pmlmeext->mlmext_info;
344		344
345	if ((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && ((pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE))	345	if ((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && ((pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE))
346	return true;	346	return true;
347	else	347
348	return _FAIL;	348	return false;
349	}	349	}
350		350
351	int is_client_associated_to_ibss(struct adapter *padapter)	351	bool r8188eu_is_client_associated_to_ibss(struct adapter *padapter)
352	{	352	{
353	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	353	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
354	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;	354	struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
355		355
356	if ((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && ((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE))	356	if ((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && ((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE))
357	return true;	357	return true;
358	else	358
359	return _FAIL;	359	return false;
360	}	360	}
361		361
362	int is_IBSS_empty(struct adapter *padapter)	362	bool r8188eu_is_ibss_empty(struct adapter *padapter)
363	{	363	{
364	unsigned int i;	364	unsigned int i;
365	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;	365	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
@@ -367,7 +367,7 @@ int is_IBSS_empty(struct adapter *padapter) · 1 unmodified line
367		367
368	for (i = IBSS_START_MAC_ID; i < NUM_STA; i++) {	368	for (i = IBSS_START_MAC_ID; i < NUM_STA; i++) {
369	if (pmlmeinfo->FW_sta_info[i].status == 1)	369	if (pmlmeinfo->FW_sta_info[i].status == 1)
370	return _FAIL;	370	return false;
371	}	371	}
372	return true;	372	return true;
373	}	373	}
@@ -874,9 +874,10 @@ void VCS_update(struct adapter padapter, struct sta_info psta) · 500 unmodified lines
874		874
875	int rtw_check_bcn_info(struct adapter Adapter, u8 pframe, u32 packet_len)	875	int rtw_check_bcn_info(struct adapter Adapter, u8 pframe, u32 packet_len)
876	{	876	{
		877	struct ieee80211_mgmt mgmt = (struct ieee80211_mgmt )pframe;
877	unsigned int len;	878	unsigned int len;
878	unsigned char *p;	879	unsigned char *p;
879	unsigned short val16, subtype;	880	unsigned short val16;
880	struct wlan_network *cur_network = &Adapter->mlmepriv.cur_network;	881	struct wlan_network *cur_network = &Adapter->mlmepriv.cur_network;
881	/* u8 wpa_ie[255], rsn_ie[255]; */	882	/* u8 wpa_ie[255], rsn_ie[255]; */
882	u16 wpa_len = 0, rsn_len = 0;	883	u16 wpa_len = 0, rsn_len = 0;
@@ -893,7 +894,7 @@ int rtw_check_bcn_info(struct adapter Adapter, u8 pframe, u32 packet_len) · 10 unmodified lines
893	unsigned short ht_cap_info;	894	unsigned short ht_cap_info;
894	unsigned char ht_info_infos_0;	895	unsigned char ht_info_infos_0;
895		896
896	if (!is_client_associated_to_ap(Adapter))	897	if (!r8188eu_is_client_associated_to_ap(Adapter))
897	return true;	898	return true;
898		899
899	len = packet_len - sizeof(struct ieee80211_hdr_3addr);	900	len = packet_len - sizeof(struct ieee80211_hdr_3addr);
@@ -908,9 +909,7 @@ int rtw_check_bcn_info(struct adapter Adapter, u8 pframe, u32 packet_len) · 8 unmodified lines
908	if (!bssid)	909	if (!bssid)
909	return _FAIL;	910	return _FAIL;
910		911
911	subtype = GetFrameSubType(pframe) >> 4;	912	if (ieee80211_is_beacon(mgmt->frame_control))
912
913	if (subtype == WIFI_BEACON)
914	bssid->Reserved[0] = 1;	913	bssid->Reserved[0] = 1;
915		914
916	bssid->Length = sizeof(struct wlan_bssid_ex) - MAX_IE_SZ + len;	915	bssid->Length = sizeof(struct wlan_bssid_ex) - MAX_IE_SZ + len;
@@ -1035,16 +1034,13 @@ _mismatch: · 118 unmodified lines
1035	return _FAIL;	1034	return _FAIL;
1036	}	1035	}
1037		1036
1038	void update_beacon_info(struct adapter padapter, u8 pframe, uint pkt_len, struct sta_info *psta)	1037	void update_beacon_info(struct adapter padapter, u8 ie_ptr, uint ie_len, struct sta_info *psta)
1039	{	1038	{
1040	unsigned int i;	1039	unsigned int i;
1041	unsigned int len;
1042	struct ndis_802_11_var_ie *pIE;	1040	struct ndis_802_11_var_ie *pIE;
1043		1041
1044	len = pkt_len - (_BEACON_IE_OFFSET_ + WLAN_HDR_A3_LEN);	1042	for (i = 0; i < ie_len;) {
1045		1043	pIE = (struct ndis_802_11_var_ie *)(ie_ptr + i);
1046	for (i = 0; i < len;) {
1047	pIE = (struct ndis_802_11_var_ie *)(pframe + (_BEACON_IE_OFFSET_ + WLAN_HDR_A3_LEN) + i);
1048		1044
1049	switch (pIE->ElementID) {	1045	switch (pIE->ElementID) {
1050	case _HT_EXTRA_INFO_IE_: /* HT info */	1046	case _HT_EXTRA_INFO_IE_: /* HT info */

drivers/staging/r8188eu/core/rtw_xmit.c+20−34

 {
 	pxmitbuf->pallocated_buf = kzalloc(alloc_sz, GFP_KERNEL);
 	if (!pxmitbuf->pallocated_buf)
-		return _FAIL;
+		return -ENOMEM;
 	pxmitbuf->pbuf = (u8 *)ALIGN((size_t)(pxmitbuf->pallocated_buf), XMITBUF_ALIGN_SZ);
 	pxmitbuf->dma_transfer_addr = 0;
 	pxmitbuf->pxmit_urb = usb_alloc_urb(0, GFP_KERNEL);
 	if (!pxmitbuf->pxmit_urb) {
 		kfree(pxmitbuf->pallocated_buf);
-		return _FAIL;
+		return -ENOMEM;
 	}
-	return _SUCCESS;
+	return 0;
 }
 static void rtw_xmit_resource_free(struct adapter *padapter, struct xmit_buf *pxmitbuf,
 	kfree(pxmitbuf->pallocated_buf);
 }
-s32	_rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, struct adapter *padapter)
+int _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, struct adapter *padapter)
 {
 	int i;
 	struct xmit_buf *pxmitbuf;
 	struct xmit_frame *pxframe;
-	int	res = _SUCCESS;
 	u32 max_xmit_extbuf_size = MAX_XMIT_EXTBUF_SZ;
 	u32 num_xmit_extbuf = NR_XMIT_EXTBUFF;
 	if (!pxmitpriv->pallocated_frame_buf) {
 		pxmitpriv->pxmit_frame_buf = NULL;
-		res = _FAIL;
 		goto exit;
 	}
 	pxmitpriv->pxmit_frame_buf = (u8 *)ALIGN((size_t)(pxmitpriv->pallocated_frame_buf), 4);
 	pxmitpriv->pallocated_xmitbuf = vzalloc(NR_XMITBUFF * sizeof(struct xmit_buf) + 4);
-	if (!pxmitpriv->pallocated_xmitbuf) {
+	if (!pxmitpriv->pallocated_xmitbuf)
-		res = _FAIL;
 		goto free_frame_buf;
-	}
 	pxmitpriv->pxmitbuf = (u8 *)ALIGN((size_t)(pxmitpriv->pallocated_xmitbuf), 4);
 	/* pxmitpriv->pxmitbuf = pxmitpriv->pallocated_xmitbuf + 4 - */
 		pxmitbuf->ext_tag = false;
 		/* Tx buf allocation may fail sometimes, so sleep and retry. */
-		res = rtw_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ));
+		if (rtw_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ))) {
-		if (res == _FAIL) {
 			msleep(10);
-			res = rtw_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ));
+			if (rtw_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ)))
-			if (res == _FAIL)
 				goto free_xmitbuf;
 		}
 	pxmitpriv->pallocated_xmit_extbuf = vzalloc(num_xmit_extbuf * sizeof(struct xmit_buf) + 4);
-	if (!pxmitpriv->pallocated_xmit_extbuf) {
+	if (!pxmitpriv->pallocated_xmit_extbuf)
-		res = _FAIL;
 		goto free_xmitbuf;
-	}
 	pxmitpriv->pxmit_extbuf = (u8 *)ALIGN((size_t)(pxmitpriv->pallocated_xmit_extbuf), 4);
 		pxmitbuf->padapter = padapter;
 		pxmitbuf->ext_tag = true;
-		res = rtw_xmit_resource_alloc(padapter, pxmitbuf, max_xmit_extbuf_size + XMITBUF_ALIGN_SZ);
+		if (rtw_xmit_resource_alloc(padapter, pxmitbuf, max_xmit_extbuf_size + XMITBUF_ALIGN_SZ))
-		if (res == _FAIL) {
-			res = _FAIL;
 			goto free_xmit_extbuf;
-		}
 		list_add_tail(&pxmitbuf->list, &pxmitpriv->free_xmit_extbuf_queue.queue);
 		pxmitbuf++;
 	pxmitpriv->free_xmit_extbuf_cnt = num_xmit_extbuf;
-	if (rtw_alloc_hwxmits(padapter)) {
+	if (rtw_alloc_hwxmits(padapter))
-		res = _FAIL;
 		goto free_xmit_extbuf;
-	}
 	rtw_init_hwxmits(pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry);
 	rtl8188eu_init_xmit_priv(padapter);
-	return _SUCCESS;
+	return 0;
 free_xmit_extbuf:
 	pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
 free_frame_buf:
 	vfree(pxmitpriv->pallocated_frame_buf);
 exit:
-	return res;
+	return -ENOMEM;
 }
 static void rtw_pkt_complete(struct adapter *padapter, struct sk_buff *pkt)
 {
 	uint len;
-	len = rtw_remainder_len(pfile);
+	len = min(rtw_remainder_len(pfile), rlen);
-	len = (rlen > len) ? len : rlen;
 	if (rmem)
 		skb_copy_bits(pfile->pkt, pfile->buf_len - pfile->pkt_len, rmem, len);
 	spin_lock_bh(&padapter->br_ext_lock);
 	if (!(skb->data[0] & 1) && br_port &&
 	    memcmp(skb->data + ETH_ALEN, padapter->br_mac, ETH_ALEN) &&
-	    *((__be16 *)(skb->data + ETH_ALEN * 2)) != __constant_htons(ETH_P_8021Q) &&
+	    *((__be16 *)(skb->data + ETH_ALEN * 2)) != htons(ETH_P_8021Q) &&
-	    *((__be16 *)(skb->data + ETH_ALEN * 2)) == __constant_htons(ETH_P_IP) &&
+	    *((__be16 *)(skb->data + ETH_ALEN * 2)) == htons(ETH_P_IP) &&
 	    !memcmp(padapter->scdb_mac, skb->data + ETH_ALEN, ETH_ALEN) && padapter->scdb_entry) {
 		memcpy(skb->data + ETH_ALEN, GET_MY_HWADDR(padapter), ETH_ALEN);
 		padapter->scdb_entry->ageing_timer = jiffies;
 		spin_unlock_bh(&padapter->br_ext_lock);
 	} else {
-		if (*((__be16 *)(skb->data + ETH_ALEN * 2)) == __constant_htons(ETH_P_8021Q)) {
+		if (*((__be16 *)(skb->data + ETH_ALEN * 2)) == htons(ETH_P_8021Q)) {
 			is_vlan_tag = 1;
 			vlan_hdr = *((unsigned short *)(skb->data + ETH_ALEN * 2 + 2));
 			for (i = 0; i < 6; i++)
 			skb_pull(skb, 4);
 		}
 		if (!memcmp(skb->data + ETH_ALEN, padapter->br_mac, ETH_ALEN) &&
-		    (*((__be16 *)(skb->data + ETH_ALEN * 2)) == __constant_htons(ETH_P_IP)))
+		    (*((__be16 *)(skb->data + ETH_ALEN * 2)) == htons(ETH_P_IP)))
 			memcpy(padapter->br_ip, skb->data + WLAN_ETHHDR_LEN + 12, 4);
-		if (*((__be16 *)(skb->data + ETH_ALEN * 2)) == __constant_htons(ETH_P_IP)) {
+		if (*((__be16 *)(skb->data + ETH_ALEN * 2)) == htons(ETH_P_IP)) {
 			if (memcmp(padapter->scdb_mac, skb->data + ETH_ALEN, ETH_ALEN)) {
 				padapter->scdb_entry = (struct nat25_network_db_entry *)scdb_findEntry(padapter,
 							skb->data + WLAN_ETHHDR_LEN + 12);
 					skb_push(skb, 4);
 					for (i = 0; i < 6; i++)
 						*((unsigned short *)(skb->data + i * 2)) = *((unsigned short *)(skb->data + 4 + i * 2));
-					*((__be16 *)(skb->data + ETH_ALEN * 2)) = __constant_htons(ETH_P_8021Q);
+					*((__be16 *)(skb->data + ETH_ALEN * 2)) = htons(ETH_P_8021Q);
 					*((unsigned short *)(skb->data + ETH_ALEN * 2 + 2)) = vlan_hdr;
 				}
 			skb_push(skb, 4);
 			for (i = 0; i < 6; i++)
 				*((unsigned short *)(skb->data + i * 2)) = *((unsigned short *)(skb->data + 4 + i * 2));
-			*((__be16 *)(skb->data + ETH_ALEN * 2)) = __constant_htons(ETH_P_8021Q);
+			*((__be16 *)(skb->data + ETH_ALEN * 2)) = htons(ETH_P_8021Q);
 			*((unsigned short *)(skb->data + ETH_ALEN * 2 + 2)) = vlan_hdr;
 		}
 	}

drivers/staging/r8188eu/hal/HalPhyRf_8188e.c+2−10

 /*-----------------------------------------------------------------------------
  * Function:	odm_TxPwrTrackSetPwr88E()
  *
- * Overview:	88E change all channel tx power accordign to flag.
+ * Overview:	88E change all channel tx power according to flag.
  *				OFDM & CCK are all different.
  *
  * Input:		NONE
 			tmp2 = resulta[c2][i];
 		}
-		diff = (tmp1 > tmp2) ? (tmp1 - tmp2) : (tmp2 - tmp1);
+		diff = abs(tmp1 - tmp2);
 		if (diff > MAX_TOLERANCE) {
 			if ((i == 2 || i == 6) && !sim_bitmap) {
 	if (RegE94 != 0)
 		patha_fill_iqk(adapt, pathaok, result, final_candidate, (RegEA4 == 0));
-/* To Fix BSOD when final_candidate is 0xff */
-/* by sherry 20120321 */
-	if (final_candidate < 4) {
-		for (i = 0; i < IQK_Matrix_REG_NUM; i++)
-			dm_odm->RFCalibrateInfo.IQKMatrixRegSetting.Value[0][i] = result[final_candidate][i];
-		dm_odm->RFCalibrateInfo.IQKMatrixRegSetting.bIQKDone = true;
-	}
 	_PHY_SaveADDARegisters(adapt, IQK_BB_REG_92C, dm_odm->RFCalibrateInfo.IQK_BB_backup_recover, 9);
 }

drivers/staging/r8188eu/hal/hal_intf.c+7−12

 #include "../include/drv_types.h"
 #include "../include/hal_intf.h"
-uint	 rtw_hal_init(struct adapter *adapt)
+uint rtw_hal_init(struct adapter *adapt)
 {
-	uint	status = _SUCCESS;
 	adapt->hw_init_completed = false;
-	status = rtl8188eu_hal_init(adapt);
+	if (rtl8188eu_hal_init(adapt) != _SUCCESS)
+		return _FAIL;
-	if (status == _SUCCESS) {
+	adapt->hw_init_completed = true;
-		adapt->hw_init_completed = true;
-		if (adapt->registrypriv.notch_filter == 1)
+	if (adapt->registrypriv.notch_filter == 1)
-			hal_notch_filter_8188e(adapt, 1);
+		hal_notch_filter_8188e(adapt, 1);
-	} else {
-		adapt->hw_init_completed = false;
-	}
-	return status;
+	return _SUCCESS;
 }
 uint rtw_hal_deinit(struct adapter *adapt)

drivers/staging/r8188eu/hal/odm_RTL8188E.c+3−3

@@ -194,12 +194,12 @@ static void odm_HWAntDiv(struct odm_dm_struct *dm_odm) · 193 unmodified lines
194	for (i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++) {	194	for (i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++) {
195	pEntry = dm_odm->pODM_StaInfo[i];	195	pEntry = dm_odm->pODM_StaInfo[i];
196	if (IS_STA_VALID(pEntry)) {	196	if (IS_STA_VALID(pEntry)) {
197	/* 2 Caculate RSSI per Antenna */	197	/* 2 Calculate RSSI per Antenna */
198	Main_RSSI = (dm_fat_tbl->MainAnt_Cnt[i] != 0) ? (dm_fat_tbl->MainAnt_Sum[i] / dm_fat_tbl->MainAnt_Cnt[i]) : 0;	198	Main_RSSI = (dm_fat_tbl->MainAnt_Cnt[i] != 0) ? (dm_fat_tbl->MainAnt_Sum[i] / dm_fat_tbl->MainAnt_Cnt[i]) : 0;
199	Aux_RSSI = (dm_fat_tbl->AuxAnt_Cnt[i] != 0) ? (dm_fat_tbl->AuxAnt_Sum[i] / dm_fat_tbl->AuxAnt_Cnt[i]) : 0;	199	Aux_RSSI = (dm_fat_tbl->AuxAnt_Cnt[i] != 0) ? (dm_fat_tbl->AuxAnt_Sum[i] / dm_fat_tbl->AuxAnt_Cnt[i]) : 0;
200	TargetAnt = (Main_RSSI >= Aux_RSSI) ? MAIN_ANT : AUX_ANT;	200	TargetAnt = (Main_RSSI >= Aux_RSSI) ? MAIN_ANT : AUX_ANT;
201	/* 2 Select MaxRSSI for DIG */	201	/* 2 Select MaxRSSI for DIG */
202	LocalMaxRSSI = (Main_RSSI > Aux_RSSI) ? Main_RSSI : Aux_RSSI;	202	LocalMaxRSSI = max(Main_RSSI, Aux_RSSI);
203	if ((LocalMaxRSSI > AntDivMaxRSSI) && (LocalMaxRSSI < 40))	203	if ((LocalMaxRSSI > AntDivMaxRSSI) && (LocalMaxRSSI < 40))
204	AntDivMaxRSSI = LocalMaxRSSI;	204	AntDivMaxRSSI = LocalMaxRSSI;
205	if (LocalMaxRSSI > MaxRSSI)	205	if (LocalMaxRSSI > MaxRSSI)
@@ -211,7 +211,7 @@ static void odm_HWAntDiv(struct odm_dm_struct *dm_odm) · 5 unmodified lines
211	else if ((dm_fat_tbl->RxIdleAnt == AUX_ANT) && (Aux_RSSI == 0))	211	else if ((dm_fat_tbl->RxIdleAnt == AUX_ANT) && (Aux_RSSI == 0))
212	Aux_RSSI = Main_RSSI;	212	Aux_RSSI = Main_RSSI;
213		213
214	LocalMinRSSI = (Main_RSSI > Aux_RSSI) ? Aux_RSSI : Main_RSSI;	214	LocalMinRSSI = min(Main_RSSI, Aux_RSSI);
215	if (LocalMinRSSI < MinRSSI) {	215	if (LocalMinRSSI < MinRSSI) {
216	MinRSSI = LocalMinRSSI;	216	MinRSSI = LocalMinRSSI;
217	RxIdleAnt = TargetAnt;	217	RxIdleAnt = TargetAnt;

drivers/staging/r8188eu/hal/rtl8188e_hal_init.c+2−6

 	if (PwrState) {
 		rtw_write8(pAdapter, REG_EFUSE_ACCESS, EFUSE_ACCESS_ON);
-		/*  1.2V Power: From VDDON with Power Cut(0x0000h[15]), defualt valid */
+		/*  1.2V Power: From VDDON with Power Cut(0x0000h[15]), default valid */
 		res = rtw_read16(pAdapter, REG_SYS_ISO_CTRL, &tmpV16);
 		if (res)
 			return;
 	return status;
 }
-void
+void Hal_EfuseParseIDCode88E(struct adapter *padapter, u8 *hwinfo)
-Hal_EfuseParseIDCode88E(
-		struct adapter *padapter,
-		u8 *hwinfo
-	)
 {
 	struct eeprom_priv *pEEPROM = &padapter->eeprompriv;
 	struct net_device *netdev = padapter->pnetdev;

drivers/staging/r8188eu/hal/rtl8188e_phycfg.c+8−8

@@ -23,7 +23,7 @@ static u32 phy_calculate_bit_shift(u32 bitmask) · 22 unmodified lines
23	/**	23	/**
24	* Function: PHY_QueryBBReg	24	* Function: PHY_QueryBBReg
25	*	25	*
26	* OverView: Read "sepcific bits" from BB register	26	* Overview: Read "sepcific bits" from BB register
27	*	27	*
28	* Input:	28	* Input:
29	* struct adapter *Adapter,	29	* struct adapter *Adapter,
@@ -56,7 +56,7 @@ rtl8188e_PHY_QueryBBReg( · 26 unmodified lines
56	/**	56	/**
57	* Function: PHY_SetBBReg	57	* Function: PHY_SetBBReg
58	*	58	*
59	* OverView: Write "Specific bits" to BB register (page 8~)	59	* Overview: Write "Specific bits" to BB register (page 8~)
60	*	60	*
61	* Input:	61	* Input:
62	* struct adapter *Adapter,	62	* struct adapter *Adapter,
@@ -94,7 +94,7 @@ void rtl8188e_PHY_SetBBReg(struct adapter *Adapter, u32 RegAddr, u32 BitMask, u3 · 31 unmodified lines
94	/**	94	/**
95	* Function: phy_RFSerialRead	95	* Function: phy_RFSerialRead
96	*	96	*
97	* OverView: Read regster from RF chips	97	* Overview: Read register from RF chips
98	*	98	*
99	* Input:	99	* Input:
100	* struct adapter *Adapter,	100	* struct adapter *Adapter,
@@ -160,7 +160,7 @@ phy_RFSerialRead( · 59 unmodified lines
160	/**	160	/**
161	* Function: phy_RFSerialWrite	161	* Function: phy_RFSerialWrite
162	*	162	*
163	* OverView: Write data to RF register (page 8~)	163	* Overview: Write data to RF register (page 8~)
164	*	164	*
165	* Input:	165	* Input:
166	* struct adapter *Adapter,	166	* struct adapter *Adapter,
@@ -235,7 +235,7 @@ phy_RFSerialWrite( · 68 unmodified lines
235	/**	235	/**
236	* Function: PHY_QueryRFReg	236	* Function: PHY_QueryRFReg
237	*	237	*
238	* OverView: Query "Specific bits" to RF register (page 8~)	238	* Overview: Query "Specific bits" to RF register (page 8~)
239	*	239	*
240	* Input:	240	* Input:
241	* struct adapter *Adapter,	241	* struct adapter *Adapter,
@@ -261,7 +261,7 @@ u32 rtl8188e_PHY_QueryRFReg(struct adapter *Adapter, u32 RegAddr, u32 BitMask) · 19 unmodified lines
261	/**	261	/**
262	* Function: PHY_SetRFReg	262	* Function: PHY_SetRFReg
263	*	263	*
264	* OverView: Write "Specific bits" to RF register (page 8~)	264	* Overview: Write "Specific bits" to RF register (page 8~)
265	*	265	*
266	* Input:	266	* Input:
267	* struct adapter *Adapter,	267	* struct adapter *Adapter,
@@ -335,7 +335,7 @@ s32 PHY_MACConfig8188E(struct adapter *Adapter) · 67 unmodified lines
335	/**	335	/**
336	* Function: phy_InitBBRFRegisterDefinition	336	* Function: phy_InitBBRFRegisterDefinition
337	*	337	*
338	* OverView: Initialize Register definition offset for Radio Path A/B/C/D	338	* Overview: Initialize Register definition offset for Radio Path A/B/C/D
339	*	339	*
340	* Input:	340	* Input:
341	* struct adapter *Adapter,	341	* struct adapter *Adapter,
@@ -363,7 +363,7 @@ phy_InitBBRFRegisterDefinition( · 21 unmodified lines
363	/* RF Interface (Output and) Enable */	363	/* RF Interface (Output and) Enable */
364	pHalData->PHYRegDef.rfintfe = rFPGA0_XA_RFInterfaceOE; /* 16 MSBs if read 32-bit from 0x860 (16-bit for 0x862) */	364	pHalData->PHYRegDef.rfintfe = rFPGA0_XA_RFInterfaceOE; /* 16 MSBs if read 32-bit from 0x860 (16-bit for 0x862) */
365		365
366	/* Addr of LSSI. Wirte RF register by driver */	366	/* Addr of LSSI. Write RF register by driver */
367	pHalData->PHYRegDef.rf3wireOffset = rFPGA0_XA_LSSIParameter; /* LSSI Parameter */	367	pHalData->PHYRegDef.rf3wireOffset = rFPGA0_XA_LSSIParameter; /* LSSI Parameter */
368		368
369	/* RF parameter */	369	/* RF parameter */

drivers/staging/r8188eu/hal/rtl8188e_rxdesc.c+13−15

@@ -66,28 +66,25 @@ void update_recvframe_attrib_88e(struct recv_frame *precvframe, struct recv_stat · 65 unmodified lines
66		66
67	if (pattrib->pkt_rpt_type == NORMAL_RX) {	67	if (pattrib->pkt_rpt_type == NORMAL_RX) {
68	pattrib->pkt_len = le32_to_cpu(prxstat->rxdw0) & 0x00003fff;	68	pattrib->pkt_len = le32_to_cpu(prxstat->rxdw0) & 0x00003fff;
		69	pattrib->icv_err = (le32_to_cpu(prxstat->rxdw0) >> 15) & 0x1;
69	pattrib->drvinfo_sz = ((le32_to_cpu(prxstat->rxdw0) >> 16) & 0xf) * 8;	70	pattrib->drvinfo_sz = ((le32_to_cpu(prxstat->rxdw0) >> 16) & 0xf) * 8;
70		71	pattrib->encrypt = (u8)((le32_to_cpu(prxstat->rxdw0) >> 20) & 0x7);
		72	pattrib->qos = (le32_to_cpu(prxstat->rxdw0) >> 23) & 0x1;
		73	pattrib->shift_sz = (le32_to_cpu(prxstat->rxdw0) >> 24) & 0x3;
71	pattrib->physt = (le32_to_cpu(prxstat->rxdw0) >> 26) & 0x1;	74	pattrib->physt = (le32_to_cpu(prxstat->rxdw0) >> 26) & 0x1;
72
73	pattrib->bdecrypted = (le32_to_cpu(prxstat->rxdw0) & BIT(27)) ? 0 : 1;	75	pattrib->bdecrypted = (le32_to_cpu(prxstat->rxdw0) & BIT(27)) ? 0 : 1;
74	pattrib->encrypt = (le32_to_cpu(prxstat->rxdw0) >> 20) & 0x7;
75		76
76	pattrib->qos = (le32_to_cpu(prxstat->rxdw0) >> 23) & 0x1;
77	pattrib->priority = (le32_to_cpu(prxstat->rxdw1) >> 8) & 0xf;	77	pattrib->priority = (le32_to_cpu(prxstat->rxdw1) >> 8) & 0xf;
78
79	pattrib->amsdu = (le32_to_cpu(prxstat->rxdw1) >> 13) & 0x1;	78	pattrib->amsdu = (le32_to_cpu(prxstat->rxdw1) >> 13) & 0x1;
		79	pattrib->mdata = (le32_to_cpu(prxstat->rxdw1) >> 26) & 0x1;
		80	pattrib->mfrag = (le32_to_cpu(prxstat->rxdw1) >> 27) & 0x1;
80		81
81	pattrib->seq_num = le32_to_cpu(prxstat->rxdw2) & 0x00000fff;	82	pattrib->seq_num = le32_to_cpu(prxstat->rxdw2) & 0x00000fff;
82	pattrib->frag_num = (le32_to_cpu(prxstat->rxdw2) >> 12) & 0xf;	83	pattrib->frag_num = (le32_to_cpu(prxstat->rxdw2) >> 12) & 0xf;
83	pattrib->mfrag = (le32_to_cpu(prxstat->rxdw1) >> 27) & 0x1;
84	pattrib->mdata = (le32_to_cpu(prxstat->rxdw1) >> 26) & 0x1;
85		84
86	pattrib->mcs_rate = le32_to_cpu(prxstat->rxdw3) & 0x3f;	85	pattrib->mcs_rate = le32_to_cpu(prxstat->rxdw3) & 0x3f;
87	pattrib->rxht = (le32_to_cpu(prxstat->rxdw3) >> 6) & 0x1;	86	pattrib->rxht = (le32_to_cpu(prxstat->rxdw3) >> 6) & 0x1;
88		87
89	pattrib->icv_err = (le32_to_cpu(prxstat->rxdw0) >> 15) & 0x1;
90	pattrib->shift_sz = (le32_to_cpu(prxstat->rxdw0) >> 24) & 0x3;
91	} else if (pattrib->pkt_rpt_type == TX_REPORT1) { /* CCX */	88	} else if (pattrib->pkt_rpt_type == TX_REPORT1) { /* CCX */
92	pattrib->pkt_len = TX_RPT1_PKT_LEN;	89	pattrib->pkt_len = TX_RPT1_PKT_LEN;
93	} else if (pattrib->pkt_rpt_type == TX_REPORT2) {	90	} else if (pattrib->pkt_rpt_type == TX_REPORT2) {
@@ -108,33 +105,34 @@ void update_recvframe_attrib_88e(struct recv_frame *precvframe, struct recv_stat · 14 unmodified lines
108	*/	105	*/
109	void update_recvframe_phyinfo_88e(struct recv_frame precvframe, struct phy_stat pphy_status)	106	void update_recvframe_phyinfo_88e(struct recv_frame precvframe, struct phy_stat pphy_status)
110	{	107	{
		108	struct ieee80211_hdr hdr = (struct ieee80211_hdr )precvframe->rx_data;
111	struct adapter *padapter = precvframe->adapter;	109	struct adapter *padapter = precvframe->adapter;
112	struct rx_pkt_attrib *pattrib = &precvframe->attrib;	110	struct rx_pkt_attrib *pattrib = &precvframe->attrib;
113	struct hal_data_8188e *pHalData = &padapter->haldata;	111	struct hal_data_8188e *pHalData = &padapter->haldata;
114	struct phy_info *pPHYInfo = &pattrib->phy_info;	112	struct phy_info *pPHYInfo = &pattrib->phy_info;
115	u8 *wlanhdr = precvframe->rx_data;	113	u8 *wlanhdr = precvframe->rx_data;
116	__le16 fc = (__le16 )wlanhdr;
117	struct odm_per_pkt_info pkt_info;	114	struct odm_per_pkt_info pkt_info;
118	u8 *sa = NULL;	115	u8 *sa = NULL;
119	struct sta_priv *pstapriv;	116	struct sta_priv *pstapriv;
120	struct sta_info *psta;	117	struct sta_info *psta;
121		118
122	pkt_info.bPacketMatchBSSID = ((!ieee80211_is_ctl(fc)) &&	119	pkt_info.bPacketMatchBSSID = ((!ieee80211_is_ctl(hdr->frame_control)) &&
123	!pattrib->icv_err && !pattrib->crc_err &&	120	!pattrib->icv_err && !pattrib->crc_err &&
124	!memcmp(get_hdr_bssid(wlanhdr),	121	!memcmp(get_hdr_bssid(wlanhdr),
125	get_bssid(&padapter->mlmepriv), ETH_ALEN));	122	get_bssid(&padapter->mlmepriv), ETH_ALEN));
126		123
127	pkt_info.bPacketToSelf = pkt_info.bPacketMatchBSSID &&	124	pkt_info.bPacketToSelf = pkt_info.bPacketMatchBSSID &&
128	(!memcmp(get_da(wlanhdr),	125	ether_addr_equal(ieee80211_get_DA(hdr),
129	myid(&padapter->eeprompriv), ETH_ALEN));	126	myid(&padapter->eeprompriv));
130		127
131	pkt_info.bPacketBeacon = pkt_info.bPacketMatchBSSID && ieee80211_is_beacon(fc);	128	pkt_info.bPacketBeacon = pkt_info.bPacketMatchBSSID &&
		129	ieee80211_is_beacon(hdr->frame_control);
132	if (pkt_info.bPacketBeacon) {	130	if (pkt_info.bPacketBeacon) {
133	if (check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE))	131	if (check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE))
134	sa = padapter->mlmepriv.cur_network.network.MacAddress;	132	sa = padapter->mlmepriv.cur_network.network.MacAddress;
135	/* to do Ad-hoc */	133	/* to do Ad-hoc */
136	} else {	134	} else {
137	sa = get_sa(wlanhdr);	135	sa = ieee80211_get_SA(hdr);
138	}	136	}
139		137
140	pstapriv = &padapter->stapriv;	138	pstapriv = &padapter->stapriv;

drivers/staging/r8188eu/hal/rtl8188eu_xmit.c+1−2

 static s32 update_txdesc(struct xmit_frame *pxmitframe, u8 *pmem, s32 sz, u8 bagg_pkt)
 {
-	int	pull = 0;
 	uint	qsel;
 	u8 data_rate, pwr_status, offset;
 	struct adapter		*adapt = pxmitframe->padapter;
 	ODM_SetTxAntByTxInfo_88E(&haldata->odmpriv, pmem, pattrib->mac_id);
 	rtl8188eu_cal_txdesc_chksum(ptxdesc);
-	return pull;
+	return 0;
 }
 /* for non-agg data frame or  management frame */

drivers/staging/r8188eu/include/Hal8188EPhyReg.h+2−2

@@ -92,7 +92,7 @@ · 91 unmodified lines
92	#define rFPGA0_AdDaClockEn 0x888	92	#define rFPGA0_AdDaClockEn 0x888
93	#define rFPGA0_AnalogParameter4 0x88c	93	#define rFPGA0_AnalogParameter4 0x88c
94		94
95	#define rFPGA0_XA_LSSIReadBack 0x8a0 /* Tranceiver LSSI Readback */	95	#define rFPGA0_XA_LSSIReadBack 0x8a0 /* Transceiver LSSI Readback */
96	#define rFPGA0_XB_LSSIReadBack 0x8a4	96	#define rFPGA0_XB_LSSIReadBack 0x8a4
97	#define rFPGA0_XC_LSSIReadBack 0x8a8	97	#define rFPGA0_XC_LSSIReadBack 0x8a8
98	#define rFPGA0_XD_LSSIReadBack 0x8ac	98	#define rFPGA0_XD_LSSIReadBack 0x8ac
@@ -167,7 +167,7 @@ · 68 unmodified lines
167		167
168	/* RxIQ DC offset, Rx digital filter, DC notch filter */	168	/* RxIQ DC offset, Rx digital filter, DC notch filter */
169	#define rOFDM0_XARxAFE 0xc10	169	#define rOFDM0_XARxAFE 0xc10
170	#define rOFDM0_XARxIQImbalance 0xc14 /* RxIQ imblance matrix */	170	#define rOFDM0_XARxIQImbalance 0xc14 /* RxIQ imbalance matrix */
171	#define rOFDM0_XBRxAFE 0xc18	171	#define rOFDM0_XBRxAFE 0xc18
172	#define rOFDM0_XBRxIQImbalance 0xc1c	172	#define rOFDM0_XBRxIQImbalance 0xc1c
173	#define rOFDM0_XCRxAFE 0xc20	173	#define rOFDM0_XCRxAFE 0xc20

drivers/staging/r8188eu/include/drv_types.h+0−1

@@ -167,7 +167,6 @@ struct adapter { · 166 unmodified lines
167		167
168	s32 bDriverStopped;	168	s32 bDriverStopped;
169	s32 bSurpriseRemoved;	169	s32 bSurpriseRemoved;
170	s32 bCardDisableWOHSM;
171		170
172	u8 hw_init_completed;	171	u8 hw_init_completed;
173	s8 signal_strength;	172	s8 signal_strength;

drivers/staging/r8188eu/include/odm.h+2−8

 #define HP_THERMAL_NUM		8
 #define AVG_THERMAL_NUM		8
-#define IQK_Matrix_REG_NUM	8
 struct odm_phy_dbg_info {
 	/* ODM Write,debug info */
 	ODM_BB_PWR_TRA			= BIT(8),
 };
-# define ODM_ITRF_USB 0x2
+#define ODM_ITRF_USB	0x2
+#define ODM_CE		0x04
 /*  ODM_CMNINFO_WM_MODE */
 enum odm_wireless_mode {
 	u8 PTSmoothFactor;
 };
-struct ijk_matrix_regs_set {
-	bool	bIQKDone;
-	s32	Value[1][IQK_Matrix_REG_NUM];
-};
 struct odm_rf_cal {
 	/* for tx power tracking */
 	u32	RegA24; /*  for TempCCK */
 	u8	ThermalValue_HP[HP_THERMAL_NUM];
 	u8	ThermalValue_HP_index;
-	struct ijk_matrix_regs_set IQKMatrixRegSetting;
 	u8	Delta_IQK;
 	u8	Delta_LCK;

drivers/staging/r8188eu/include/odm_RTL8188E.h+7−0

@@ -11,6 +11,13 @@ · 10 unmodified lines
11	#define MAIN_ANT_CGCS_RX 0	11	#define MAIN_ANT_CGCS_RX 0
12	#define AUX_ANT_CGCS_RX 1	12	#define AUX_ANT_CGCS_RX 1
13		13
		14	#define SET_TX_DESC_ANTSEL_A_88E(__ptxdesc, __value) \
		15	le32p_replace_bits((__le32 *)(__ptxdesc + 8), __value, BIT(24))
		16	#define SET_TX_DESC_ANTSEL_B_88E(__ptxdesc, __value) \
		17	le32p_replace_bits((__le32 *)(__ptxdesc + 8), __value, BIT(25))
		18	#define SET_TX_DESC_ANTSEL_C_88E(__ptxdesc, __value) \
		19	le32p_replace_bits((__le32 *)(__ptxdesc + 28), __value, BIT(29))
		20
14	void ODM_AntennaDiversityInit_88E(struct odm_dm_struct *pDM_Odm);	21	void ODM_AntennaDiversityInit_88E(struct odm_dm_struct *pDM_Odm);
15		22
16	void ODM_AntennaDiversity_88E(struct odm_dm_struct *pDM_Odm);	23	void ODM_AntennaDiversity_88E(struct odm_dm_struct *pDM_Odm);

drivers/staging/r8188eu/include/odm_types.h+0−16

@@ -1,16 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */
2	/* Copyright(c) 2007 - 2011 Realtek Corporation. */
3
4	#ifndef __ODM_TYPES_H__
5	#define __ODM_TYPES_H__
6
7	#define ODM_CE 0x04 /* BIT(2) */
8
9	#define SET_TX_DESC_ANTSEL_A_88E(__ptxdesc, __value) \
10	le32p_replace_bits((__le32 *)(__ptxdesc + 8), __value, BIT(24))
11	#define SET_TX_DESC_ANTSEL_B_88E(__ptxdesc, __value) \
12	le32p_replace_bits((__le32 *)(__ptxdesc + 8), __value, BIT(25))
13	#define SET_TX_DESC_ANTSEL_C_88E(__ptxdesc, __value) \
14	le32p_replace_bits((__le32 *)(__ptxdesc + 28), __value, BIT(29))
15
16	#endif /* __ODM_TYPES_H__ */

drivers/staging/r8188eu/include/osdep_intf.h+3−3

@@ -43,10 +43,10 @@ int netdev_open(struct net_device *pnetdev); · 42 unmodified lines
43	int netdev_close(struct net_device *pnetdev);	43	int netdev_close(struct net_device *pnetdev);
44		44
45	u8 rtw_init_drv_sw(struct adapter *padapter);	45	u8 rtw_init_drv_sw(struct adapter *padapter);
46	u8 rtw_free_drv_sw(struct adapter *padapter);	46	void rtw_free_drv_sw(struct adapter *padapter);
47	u8 rtw_reset_drv_sw(struct adapter *padapter);	47	void rtw_reset_drv_sw(struct adapter *padapter);
48		48
49	u32 rtw_start_drv_threads(struct adapter *padapter);	49	int rtw_start_drv_threads(struct adapter *padapter);
50	void rtw_stop_drv_threads (struct adapter *padapter);	50	void rtw_stop_drv_threads (struct adapter *padapter);
51	void rtw_cancel_all_timer(struct adapter *padapter);	51	void rtw_cancel_all_timer(struct adapter *padapter);
52		52

drivers/staging/r8188eu/include/osdep_service.h+3−3

@@ -53,7 +53,7 @@ static inline struct list_head get_list_head(struct __queue queue) · 52 unmodified lines
53	return (&(queue->queue));	53	return (&(queue->queue));
54	}	54	}
55		55
56	static inline void _set_timer(struct timer_list *ptimer,u32 delay_time)	56	static inline void _set_timer(struct timer_list *ptimer, u32 delay_time)
57	{	57	{
58	mod_timer(ptimer, jiffies + msecs_to_jiffies(delay_time));	58	mod_timer(ptimer, jiffies + msecs_to_jiffies(delay_time));
59	}	59	}
@@ -66,7 +66,7 @@ static inline int rtw_netif_queue_stopped(struct net_device *pnetdev) · 6 unmodified lines
66	netif_tx_queue_stopped(netdev_get_tx_queue(pnetdev, 3));	66	netif_tx_queue_stopped(netdev_get_tx_queue(pnetdev, 3));
67	}	67	}
68		68
69	extern int RTW_STATUS_CODE(int error_code);	69	int RTW_STATUS_CODE(int error_code);
70		70
71	void *rtw_malloc2d(int h, int w, int size);	71	void *rtw_malloc2d(int h, int w, int size);
72		72
@@ -108,7 +108,7 @@ void rtw_free_netdev(struct net_device *netdev); · 35 unmodified lines
108	#define FUNC_ADPT_FMT "%s(%s)"	108	#define FUNC_ADPT_FMT "%s(%s)"
109	#define FUNC_ADPT_ARG(adapter) __func__, adapter->pnetdev->name	109	#define FUNC_ADPT_ARG(adapter) __func__, adapter->pnetdev->name
110		110
111	#define rtw_signal_process(pid, sig) kill_pid(find_vpid((pid)),(sig), 1)	111	#define rtw_signal_process(pid, sig) kill_pid(find_vpid((pid)), (sig), 1)
112		112
113	/* Macros for handling unaligned memory accesses */	113	/* Macros for handling unaligned memory accesses */
114		114

drivers/staging/r8188eu/include/rtl8188e_hal.h+3−4

 #include "rtl8188e_xmit.h"
 #include "rtl8188e_cmd.h"
 #include "rtw_efuse.h"
-#include "odm_types.h"
 #include "odm.h"
 #include "odm_HWConfig.h"
 #include "odm_RegDefine11N.h"
 /*  9bytes + 1byt + 5bytes and pre 1byte. */
 /*  For worst case: */
 /*  | 2byte|----8bytes----|1byte|--7bytes--| 92D */
-/*  PG data exclude header, dummy 7 bytes frome CP test and reserved 1byte. */
+/*  PG data exclude header, dummy 7 bytes from CP test and reserved 1byte. */
 #define		EFUSE_OOB_PROTECT_BYTES_88E	18
 #define EFUSE_PROTECT_BYTES_BANK	16
 void rtl8188e_EfuseParseChnlPlan(struct adapter *padapter, u8 *hwinfo,
 				 bool AutoLoadFail);
-void Hal_ReadAntennaDiversity88E(struct adapter *pAdapter,u8 *PROMContent,
+void Hal_ReadAntennaDiversity88E(struct adapter *pAdapter, u8 *PROMContent,
 				 bool AutoLoadFail);
-void Hal_ReadThermalMeter_88E(struct adapter *	dapter, u8 *PROMContent,
+void Hal_ReadThermalMeter_88E(struct adapter *padapter, u8 *PROMContent,
 			      bool AutoloadFail);
 void Hal_EfuseParseXtal_8188E(struct adapter *pAdapter, u8 *hwinfo,
 			      bool AutoLoadFail);

drivers/staging/r8188eu/include/rtl8188e_spec.h+9−9

@@ -4,7 +4,7 @@ · 3 unmodified lines
4	#ifndef __RTL8188E_SPEC_H__	4	#ifndef __RTL8188E_SPEC_H__
5	#define __RTL8188E_SPEC_H__	5	#define __RTL8188E_SPEC_H__
6		6
7	/* 8192C Regsiter offset definition */	7	/* 8192C Register offset definition */
8		8
9	#define HAL_PS_TIMER_INT_DELAY 50 /* 50 microseconds */	9	#define HAL_PS_TIMER_INT_DELAY 50 /* 50 microseconds */
10	#define HAL_92C_NAV_UPPER_UNIT 128 /* micro-second */	10	#define HAL_92C_NAV_UPPER_UNIT 128 /* micro-second */
@@ -674,7 +674,7 @@ Current IOREG MAP · 663 unmodified lines
674		674
675	#define REG_USB_HRPWM 0xFE58	675	#define REG_USB_HRPWM 0xFE58
676	#define REG_USB_HCPWM 0xFE57	676	#define REG_USB_HCPWM 0xFE57
677	/* 8192C Regsiter Bit and Content definition */	677	/* 8192C Register Bit and Content definition */
678	/* 0x0000h ~ 0x00FFh System Configuration */	678	/* 0x0000h ~ 0x00FFh System Configuration */
679		679
680	/* 2 SYS_ISO_CTRL */	680	/* 2 SYS_ISO_CTRL */
@@ -900,12 +900,12 @@ Current IOREG MAP · 219 unmodified lines
900	#define HQSEL_HIQ BIT(5)	900	#define HQSEL_HIQ BIT(5)
901		901
902	/* For normal driver, 0x10C */	902	/* For normal driver, 0x10C */
903	#define _TXDMA_HIQ_MAP(x) (((x)&0x3) << 14)	903	#define _TXDMA_HIQ_MAP(x) (((x) & 0x3) << 14)
904	#define _TXDMA_MGQ_MAP(x) (((x)&0x3) << 12)	904	#define _TXDMA_MGQ_MAP(x) (((x) & 0x3) << 12)
905	#define _TXDMA_BKQ_MAP(x) (((x)&0x3) << 10)	905	#define _TXDMA_BKQ_MAP(x) (((x) & 0x3) << 10)
906	#define _TXDMA_BEQ_MAP(x) (((x)&0x3) << 8 )	906	#define _TXDMA_BEQ_MAP(x) (((x) & 0x3) << 8)
907	#define _TXDMA_VIQ_MAP(x) (((x)&0x3) << 6 )	907	#define _TXDMA_VIQ_MAP(x) (((x) & 0x3) << 6)
908	#define _TXDMA_VOQ_MAP(x) (((x)&0x3) << 4 )	908	#define _TXDMA_VOQ_MAP(x) (((x) & 0x3) << 4)
909		909
910	#define QUEUE_LOW 1	910	#define QUEUE_LOW 1
911	#define QUEUE_NORMAL 2	911	#define QUEUE_NORMAL 2
@@ -1135,7 +1135,7 @@ Current IOREG MAP · 223 unmodified lines
1135	#define EEPROM_Default_CrystalCap_88E 0x20	1135	#define EEPROM_Default_CrystalCap_88E 0x20
1136	#define EEPROM_Default_ThermalMeter_88E 0x18	1136	#define EEPROM_Default_ThermalMeter_88E 0x18
1137		1137
1138	/* New EFUSE deafult value */	1138	/* New EFUSE default value */
1139	#define EEPROM_DEFAULT_24G_INDEX 0x2D	1139	#define EEPROM_DEFAULT_24G_INDEX 0x2D
1140	#define EEPROM_DEFAULT_24G_HT20_DIFF 0X02	1140	#define EEPROM_DEFAULT_24G_HT20_DIFF 0X02
1141	#define EEPROM_DEFAULT_24G_OFDM_DIFF 0X04	1141	#define EEPROM_DEFAULT_24G_OFDM_DIFF 0X04

drivers/staging/r8188eu/include/rtw_ap.h+1−1

@@ -26,7 +26,7 @@ u8 bss_cap_update_on_sta_leave(struct adapter padapter, struct sta_info psta); · 25 unmodified lines
26	void sta_info_update(struct adapter padapter, struct sta_info psta);	26	void sta_info_update(struct adapter padapter, struct sta_info psta);
27	u8 ap_free_sta(struct adapter padapter, struct sta_info psta,	27	u8 ap_free_sta(struct adapter padapter, struct sta_info psta,
28	bool active, u16 reason);	28	bool active, u16 reason);
29	int rtw_sta_flush(struct adapter *padapter);	29	void rtw_sta_flush(struct adapter *padapter);
30	void start_ap_mode(struct adapter *padapter);	30	void start_ap_mode(struct adapter *padapter);
31	void stop_ap_mode(struct adapter *padapter);	31	void stop_ap_mode(struct adapter *padapter);
32	void update_bmc_sta(struct adapter *padapter);	32	void update_bmc_sta(struct adapter *padapter);

drivers/staging/r8188eu/include/rtw_cmd.h+30−41

 #include "wlan_bssdef.h"
 #include "rtw_rf.h"
-#include "rtw_led.h"
-#define C2H_MEM_SZ (16*1024)
 #include "osdep_service.h"
 #include "ieee80211.h" /*  <ieee80211/ieee80211.h> */
-#define FREE_CMDOBJ_SZ	128
 #define MAX_CMDSZ	1024
 #define MAX_RSPSZ	512
 #define MAX_EVTSZ	1024
 int rtw_cmd_thread(void *context);
-u32 rtw_init_cmd_priv(struct cmd_priv *pcmdpriv);
+int rtw_init_cmd_priv(struct cmd_priv *pcmdpriv);
 void rtw_free_cmd_priv(struct cmd_priv *pcmdpriv);
-u32 rtw_init_evt_priv(struct evt_priv *pevtpriv);
+int rtw_init_evt_priv(struct evt_priv *pevtpriv);
 void rtw_free_evt_priv(struct evt_priv *pevtpriv);
 void rtw_evt_notify_isr(struct evt_priv *pevtpriv);
 u8 p2p_protocol_wk_cmd(struct adapter *padapter, int intCmdType);
 	u8	rfintfs;
 };
-struct Tx_Beacon_param
+struct Tx_Beacon_param {
-{
 	struct wlan_bssid_ex network;
 };
 	mac[0] == 0
 	==> CMD mode, return H2C_SUCCESS.
-	The following condition must be ture under CMD mode
+	The following condition must be true under CMD mode
 		mac[1] == mac[4], mac[2] == mac[3], mac[0]=mac[5]= 0;
 		s0 == 0x1234, s1 == 0xabcd, w0 == 0x78563412, w1 == 0x5aa5def7;
 		s2 == (b1 << 8 | b0);
 	unsigned char *pbuf;
 };
-/*------------------- Below are used for RF/BB tunning ---------------------*/
+/*------------------- Below are used for RF/BB tuning ---------------------*/
 struct	setantenna_parm {
 	u8	tx_antset;
 };
 struct getratable_parm {
-                uint rsvd;
+	uint rsvd;
 };
 struct getratable_rsp {
-        u8 ss_ForceUp[NumRates];
+	u8 ss_ForceUp[NumRates];
-        u8 ss_ULevel[NumRates];
+	u8 ss_ULevel[NumRates];
-        u8 ss_DLevel[NumRates];
+	u8 ss_DLevel[NumRates];
-        u8 count_judge[NumRates];
+	u8 count_judge[NumRates];
 };
 /* to get TX,RX retry count */
 };
 /*H2C Handler index: 59 */
-struct SetChannelPlan_param
+struct SetChannelPlan_param {
-{
 	u8 channel_plan;
 };
 /*H2C Handler index: 60 */
-struct LedBlink_param
+struct LedBlink_param {
-{
 	struct LED_871x *pLed;
 };
 /*H2C Handler index: 61 */
-struct SetChannelSwitch_param
+struct SetChannelSwitch_param {
-{
 	u8 new_ch_no;
 };
 /*H2C Handler index: 62 */
-struct TDLSoption_param
+struct TDLSoption_param {
-{
 	u8 addr[ETH_ALEN];
 	u8 option;
 };
 #define H2C_CMD_OVERFLOW	0x06
 #define H2C_RESERVED		0x07
-u8 rtw_sitesurvey_cmd(struct adapter  *padapter, struct ndis_802_11_ssid *ssid, int ssid_num);
+u8 rtw_sitesurvey_cmd(struct adapter *padapter, struct ndis_802_11_ssid *ssid, int ssid_num);
-u8 rtw_createbss_cmd(struct adapter  *padapter);
+u8 rtw_createbss_cmd(struct adapter *padapter);
 u8 rtw_setstakey_cmd(struct adapter *padapter, u8 *psta, u8 unicast_key);
 u8 rtw_clearstakey_cmd(struct adapter *padapter, u8 *psta, u8 entry, u8 enqueue);
-u8 rtw_joinbss_cmd(struct adapter  *padapter, struct wlan_network* pnetwork);
+u8 rtw_joinbss_cmd(struct adapter *padapter, struct wlan_network *pnetwork);
 u8 rtw_disassoc_cmd(struct adapter *padapter, u32 deauth_timeout_ms, bool enqueue);
-u8 rtw_setopmode_cmd(struct adapter  *padapter, enum ndis_802_11_network_infra networktype);
+u8 rtw_setopmode_cmd(struct adapter *padapter, enum ndis_802_11_network_infra networktype);
-u8 rtw_setdatarate_cmd(struct adapter  *padapter, u8 *rateset);
+int rtw_setdatarate_cmd(struct adapter *padapter, u8 *rateset);
-u8 rtw_setrfintfs_cmd(struct adapter  *padapter, u8 mode);
+u8 rtw_setrfintfs_cmd(struct adapter *padapter, u8 mode);
-u8 rtw_gettssi_cmd(struct adapter  *padapter, u8 offset,u8 *pval);
+u8 rtw_gettssi_cmd(struct adapter *padapter, u8 offset, u8 *pval);
-u8 rtw_setfwdig_cmd(struct adapter*padapter, u8 type);
+u8 rtw_setfwdig_cmd(struct adapter *padapter, u8 type);
-u8 rtw_setfwra_cmd(struct adapter*padapter, u8 type);
+u8 rtw_setfwra_cmd(struct adapter *padapter, u8 type);
-u8 rtw_addbareq_cmd(struct adapter*padapter, u8 tid, u8 *addr);
+u8 rtw_addbareq_cmd(struct adapter *padapter, u8 tid, u8 *addr);
 u8 rtw_dynamic_chk_wk_cmd(struct adapter *adapter);
-u8 rtw_lps_ctrl_wk_cmd(struct adapter*padapter, u8 lps_ctrl_type, u8 enqueue);
+u8 rtw_lps_ctrl_wk_cmd(struct adapter *padapter, u8 lps_ctrl_type, u8 enqueue);
-u8 rtw_rpt_timer_cfg_cmd(struct adapter*padapter, u16 minRptTime);
+u8 rtw_rpt_timer_cfg_cmd(struct adapter *padapter, u16 minRptTime);
- u8 rtw_antenna_select_cmd(struct adapter*padapter, u8 antenna,u8 enqueue);
+u8 rtw_antenna_select_cmd(struct adapter *padapter, u8 antenna, u8 enqueue);
-u8 rtw_ps_cmd(struct adapter*padapter);
+u8 rtw_ps_cmd(struct adapter *padapter);
-u8 rtw_chk_hi_queue_cmd(struct adapter*padapter);
+u8 rtw_chk_hi_queue_cmd(struct adapter *padapter);
 u8 rtw_set_chplan_cmd(struct adapter *padapter, u8 chplan);
 #define _SetRFReg_CMD_		_Write_RFREG_CMD_
 #ifdef _RTW_CMD_C_
-static struct _cmd_callback	rtw_cmd_callback[] =
+static struct _cmd_callback	rtw_cmd_callback[] = {
-{
 	{GEN_CMD_CODE(_Read_MACREG), NULL}, /*0*/
 	{GEN_CMD_CODE(_Write_MACREG), NULL},
 	{GEN_CMD_CODE(_Read_BBREG), &rtw_getbbrfreg_cmdrsp_callback},

drivers/staging/r8188eu/include/rtw_io.h+1−15

@@ -209,7 +209,7 @@ struct io_priv { · 208 unmodified lines
209	};	209	};
210		210
211	uint ioreq_flush(struct adapter adapter, struct io_queue ioqueue);	211	uint ioreq_flush(struct adapter adapter, struct io_queue ioqueue);
212	void sync_ioreq_enqueue(struct io_req preq,struct io_queue ioqueue);	212	void sync_ioreq_enqueue(struct io_req preq, struct io_queue ioqueue);
213	uint sync_ioreq_flush(struct adapter adapter, struct io_queue ioqueue);	213	uint sync_ioreq_flush(struct adapter adapter, struct io_queue ioqueue);
214	uint free_ioreq(struct io_req preq, struct io_queue pio_queue);	214	uint free_ioreq(struct io_req preq, struct io_queue pio_queue);
215	struct io_req alloc_ioreq(struct io_queue pio_q);	215	struct io_req alloc_ioreq(struct io_queue pio_q);
@@ -285,18 +285,4 @@ void bus_sync_io(struct io_queue *pio_q); · 69 unmodified lines
285	u32 _ioreq2rwmem(struct io_queue *pio_q);	285	u32 _ioreq2rwmem(struct io_queue *pio_q);
286	void dev_power_down(struct adapter *Adapter, u8 bpwrup);	286	void dev_power_down(struct adapter *Adapter, u8 bpwrup);
287		287
288	#define PlatformEFIOWrite1Byte(_a,_b,_c) \
289	rtw_write8(_a,_b,_c)
290	#define PlatformEFIOWrite2Byte(_a,_b,_c) \
291	rtw_write16(_a,_b,_c)
292	#define PlatformEFIOWrite4Byte(_a,_b,_c) \
293	rtw_write32(_a,_b,_c)
294
295	#define PlatformEFIORead1Byte(_a,_b) \
296	rtw_read8(_a,_b)
297	#define PlatformEFIORead2Byte(_a,_b) \
298	rtw_read16(_a,_b)
299	#define PlatformEFIORead4Byte(_a,_b) \
300	rtw_read32(_a,_b)
301
302	#endif /* _RTL8711_IO_H_ */	288	#endif /* _RTL8711_IO_H_ */

drivers/staging/r8188eu/include/rtw_ioctl_set.h+3−3

@@ -10,10 +10,10 @@ typedef u8 NDIS_802_11_PMKID_VALUE[16]; · 9 unmodified lines
10		10
11	u8 rtw_set_802_11_authentication_mode(struct adapter *adapt,	11	u8 rtw_set_802_11_authentication_mode(struct adapter *adapt,
12	enum ndis_802_11_auth_mode authmode);	12	enum ndis_802_11_auth_mode authmode);
13	u8 rtw_set_802_11_bssid(struct adapteradapter, u8 bssid);	13	u8 rtw_set_802_11_bssid(struct adapter adapter, u8 bssid);
14	u8 rtw_set_802_11_add_wep(struct adapter adapter, struct ndis_802_11_wep wep);	14	u8 rtw_set_802_11_add_wep(struct adapter adapter, struct ndis_802_11_wep wep);
15	u8 rtw_set_802_11_disassociate(struct adapter *adapter);	15	void rtw_set_802_11_disassociate(struct adapter *adapter);
16	u8 rtw_set_802_11_bssid_list_scan(struct adapter*adapter,	16	u8 rtw_set_802_11_bssid_list_scan(struct adapter *adapter,
17	struct ndis_802_11_ssid *pssid,	17	struct ndis_802_11_ssid *pssid,
18	int ssid_max_num);	18	int ssid_max_num);
19	u8 rtw_set_802_11_infrastructure_mode(struct adapter *adapter,	19	u8 rtw_set_802_11_infrastructure_mode(struct adapter *adapter,

drivers/staging/r8188eu/include/rtw_led.h+0−3

 };
 struct led_priv {
-	struct adapter *padapter;
 	bool bRegUseLed;
 	enum LED_STATE_871x	CurrLedState; /*  Current LED state. */
 	u32 BlinkTimes; /*  Number of times to toggle led state for blinking. */
-	bool bLedLinkBlinkInProgress;
 	bool bLedScanBlinkInProgress;
 	struct delayed_work blink_work;
 };

drivers/staging/r8188eu/include/rtw_mlme.h+11−18

 struct profile_info {
 	u8	ssidlen;
-	u8	ssid[ WLAN_SSID_MAXLEN ];
+	u8	ssid[WLAN_SSID_MAXLEN];
-	u8	peermac[ ETH_ALEN ];
+	u8	peermac[ETH_ALEN];
 };
 struct tx_invite_req_info {
 	u8	token;
 	u8	benable;
-	u8	go_ssid[ WLAN_SSID_MAXLEN ];
+	u8	go_ssid[WLAN_SSID_MAXLEN];
 	u8	ssidlen;
-	u8	go_bssid[ ETH_ALEN ];
+	u8	go_bssid[ETH_ALEN];
-	u8	peer_macaddr[ ETH_ALEN ];
+	u8	peer_macaddr[ETH_ALEN];
 	u8	operating_ch;	/* This information will be set by using the
 				 * p2p_set op_ch=x */
 	u8	peer_ch;	/* The listen channel for peer P2P device */
 };
 struct group_id_info {
-	u8	go_device_addr[ ETH_ALEN ];	/* The GO's device address of
+	u8	go_device_addr[ETH_ALEN];	/* The GO's device address of
 						 * this P2P group */
-	u8	ssid[ WLAN_SSID_MAXLEN ];	/* The SSID of this P2P group */
+	u8	ssid[WLAN_SSID_MAXLEN];	/* The SSID of this P2P group */
 };
 struct scan_limit_info {
 	return false;
 }
-static inline int get_fwstate(struct mlme_priv *pmlmepriv)
-{
-	return pmlmepriv->fw_state;
-}
 /*
  * No Limit on the calling context,
  * therefore set it to be the critical section...
 {
 	pmlmepriv->fw_state |= state;
 	/* FOR HW integration */
-	if (_FW_UNDER_SURVEY==state)
+	if (_FW_UNDER_SURVEY == state)
 		pmlmepriv->bScanInProcess = true;
 }
 {
 	pmlmepriv->fw_state &= ~state;
 	/* FOR HW integration */
-	if (_FW_UNDER_SURVEY==state)
+	if (_FW_UNDER_SURVEY == state)
 		pmlmepriv->bScanInProcess = false;
 }
 int rtw_restruct_sec_ie(struct adapter *adapter, u8 *in_ie, u8 *out_ie,
 			uint in_len);
 int rtw_restruct_wmm_ie(struct adapter *adapter, u8 *in_ie, u8 *out_ie,
-		        uint in_len, uint initial_out_len);
+			uint in_len, uint initial_out_len);
 void rtw_init_registrypriv_dev_network(struct adapter *adapter);
 void rtw_update_registrypriv_dev_network(struct adapter *adapter);
 void _rtw_free_network(struct mlme_priv *pmlmepriv,
 		       struct wlan_network *pnetwork, u8 isfreeall);
-void _rtw_free_network_nolock(struct mlme_priv *pmlmepriv,
-			      struct wlan_network *pnetwork);
-struct wlan_network* _rtw_find_network(struct __queue *scanned_queue, u8 *addr);
+struct wlan_network *_rtw_find_network(struct __queue *scanned_queue, u8 *addr);
 void _rtw_free_network_queue(struct adapter *padapter, u8 isfreeall);

drivers/staging/r8188eu/include/rtw_mlme_ext.h+14−44

 	SCAN_STATE_MAX,
 };
-typedef unsigned int (*mlme_handler)(struct adapter *adapt, struct recv_frame *frame);
+typedef void (*mlme_handler)(struct adapter *adapt, struct recv_frame *frame);
 struct	ss_res {
 	int	state;
 	u8	bwmode_updated;
 	u8	hidden_ssid_mode;
-	struct ADDBA_request	ADDBA_req;
 	struct WMM_para_element	WMM_param;
 	struct HT_caps_element	HT_caps;
 	struct HT_info_element	HT_info;
 void init_mlme_ext_priv(struct adapter *adapter);
 int init_hw_mlme_ext(struct adapter *padapter);
 void free_mlme_ext_priv (struct mlme_ext_priv *pmlmeext);
-extern struct xmit_frame *alloc_mgtxmitframe(struct xmit_priv *pxmitpriv);
+struct xmit_frame *alloc_mgtxmitframe(struct xmit_priv *pxmitpriv);
 unsigned char networktype_to_raid(unsigned char network_type);
 u8 judge_network_type(struct adapter *padapter, unsigned char *rate, int len);
 u8 *get_my_bssid(struct wlan_bssid_ex *pnetwork);
 u16 get_beacon_interval(struct wlan_bssid_ex *bss);
-int is_client_associated_to_ap(struct adapter *padapter);
+bool r8188eu_is_client_associated_to_ap(struct adapter *padapter);
-int is_client_associated_to_ibss(struct adapter *padapter);
+bool r8188eu_is_client_associated_to_ibss(struct adapter *padapter);
-int is_IBSS_empty(struct adapter *padapter);
+bool r8188eu_is_ibss_empty(struct adapter *padapter);
 unsigned char check_assoc_AP(u8 *pframe, uint len);
 void ERP_IE_handler(struct adapter *padapter, struct ndis_802_11_var_ie *pIE);
 void VCS_update(struct adapter *padapter, struct sta_info *psta);
-void update_beacon_info(struct adapter *padapter, u8 *pframe, uint len,
+void update_beacon_info(struct adapter *padapter, u8 *ie_ptr, uint ie_len, struct sta_info *psta);
-		        struct sta_info *psta);
 int rtw_check_bcn_info(struct adapter  *Adapter, u8 *pframe, u32 packet_len);
 void update_IOT_info(struct adapter *padapter);
 void update_capinfo(struct adapter *adapter, u16 updatecap);
 void report_surveydone_event(struct adapter *padapter);
 void report_del_sta_event(struct adapter *padapter,
 			  unsigned char *addr, unsigned short reason);
-void report_add_sta_event(struct adapter *padapter, unsigned char* addr,
+void report_add_sta_event(struct adapter *padapter, unsigned char *addr,
 			  int cam_idx);
 void beacon_timing_control(struct adapter *padapter);
-extern u8 set_tx_beacon_cmd(struct adapter*padapter);
+u8 set_tx_beacon_cmd(struct adapter *padapter);
 unsigned int setup_beacon_frame(struct adapter *padapter,
 				unsigned char *beacon_frame);
 void update_mgnt_tx_rate(struct adapter *padapter, u8 rate);
 void issue_p2p_provision_request(struct adapter *padapter, u8 *pssid,
 				 u8 ussidlen, u8 *pdev_raddr);
 void issue_p2p_GO_request(struct adapter *padapter, u8 *raddr);
-void issue_probereq_p2p(struct adapter *padapter, u8 *da);
+void issue_probereq_p2p(struct adapter *padapter);
 void issue_p2p_invitation_response(struct adapter *padapter, u8 *raddr,
 				   u8 dialogToken, u8 success);
-void issue_p2p_invitation_request(struct adapter *padapter, u8* raddr);
+void issue_p2p_invitation_request(struct adapter *padapter, u8 *raddr);
 void issue_beacon(struct adapter *padapter, int timeout_ms);
 void issue_probersp(struct adapter *padapter, unsigned char *da,
 		    u8 is_valid_p2p_probereq);
 		unsigned short status);
 void issue_probereq(struct adapter *padapter, struct ndis_802_11_ssid *pssid,
 		    u8 *da);
-s32 issue_probereq_ex(struct adapter *adapter, struct ndis_802_11_ssid *pssid,
+void issue_probereq_ex(struct adapter *padapter, struct ndis_802_11_ssid *pssid, u8 *da);
-		      u8* da, int try_cnt, int wait_ms);
 int issue_nulldata(struct adapter *padapter, unsigned char *da,
 		   unsigned int power_mode, int try_cnt, int wait_ms);
 int issue_qos_nulldata(struct adapter *padapter, unsigned char *da,
 		 unsigned short reason);
 int issue_deauth_ex(struct adapter *padapter, u8 *da, unsigned short reason,
 		    int try_cnt, int wait_ms);
-void issue_action_BA(struct adapter *padapter, unsigned char *raddr, u8 action, u16 status);
+void issue_action_BA(struct adapter *padapter, unsigned char *raddr, u8 action,
+		     u16 status, struct ieee80211_mgmt *mgmt_req);
 unsigned int send_delba(struct adapter *padapter, u8 initiator, u8 *addr);
 unsigned int send_beacon(struct adapter *padapter);
 bool get_beacon_valid_bit(struct adapter *adapter);
 void start_clnt_join(struct adapter *padapter);
 void start_create_ibss(struct adapter *padapter);
-unsigned int OnAssocReq(struct adapter *padapter,
-			struct recv_frame *precv_frame);
-unsigned int OnAssocRsp(struct adapter *padapter,
-			struct recv_frame *precv_frame);
-unsigned int OnProbeReq(struct adapter *padapter,
-			struct recv_frame *precv_frame);
-unsigned int OnProbeRsp(struct adapter *padapter,
-			struct recv_frame *precv_frame);
-unsigned int OnBeacon(struct adapter *padapter,
-		      struct recv_frame *precv_frame);
-unsigned int OnDisassoc(struct adapter *padapter,
-			struct recv_frame *precv_frame);
-unsigned int OnAuth(struct adapter *padapter,
-		    struct recv_frame *precv_frame);
-unsigned int OnAuthClient(struct adapter *padapter,
-			  struct recv_frame *precv_frame);
-unsigned int OnDeAuth(struct adapter *padapter,
-		      struct recv_frame *precv_frame);
-unsigned int OnAction(struct adapter *padapter,
-		      struct recv_frame *precv_frame);
-unsigned int OnAction_back(struct adapter *padapter,
-			   struct recv_frame *precv_frame);
-unsigned int on_action_public(struct adapter *padapter,
-			      struct recv_frame *precv_frame);
-unsigned int OnAction_p2p(struct adapter *padapter,
-			  struct recv_frame *precv_frame);
 void mlmeext_joinbss_event_callback(struct adapter *padapter, int join_res);
 void mlmeext_sta_del_event_callback(struct adapter *padapter);
 void mlmeext_sta_add_event_callback(struct adapter *padapter,
 	GEN_EVT_CODE(_Survey),	 /*8*/
 	GEN_EVT_CODE(_SurveyDone),	 /*9*/
-	GEN_EVT_CODE(_JoinBss) , /*10*/
+	GEN_EVT_CODE(_JoinBss), /*10*/
 	GEN_EVT_CODE(_AddSTA),
 	GEN_EVT_CODE(_DelSTA),
 	GEN_EVT_CODE(_AtimDone),

drivers/staging/r8188eu/include/rtw_recv.h+2−2

@@ -92,7 +92,7 @@ struct rx_pkt_attrib { · 91 unmodified lines
92	u8 privacy; /* in frame_ctrl field */	92	u8 privacy; /* in frame_ctrl field */
93	u8 bdecrypted;	93	u8 bdecrypted;
94	u8 encrypt; /* when 0 indicate no encrypt. when non-zero,	94	u8 encrypt; /* when 0 indicate no encrypt. when non-zero,
95	* indicate the encrypt algorith */	95	* indicate the encrypt algorithm */
96	u8 iv_len;	96	u8 iv_len;
97	u8 icv_len;	97	u8 icv_len;
98	u8 crc_err;	98	u8 crc_err;
@@ -175,7 +175,7 @@ struct recv_priv { · 76 unmodified lines
175	u8 precv_buf; / 4 alignment */	175	u8 precv_buf; / 4 alignment */
176	struct __queue free_recv_buf_queue;	176	struct __queue free_recv_buf_queue;
177	u32 free_recv_buf_queue_cnt;	177	u32 free_recv_buf_queue_cnt;
178	/* For display the phy informatiom */	178	/* For display the phy information */
179	u8 is_signal_dbg; /* for debug */	179	u8 is_signal_dbg; /* for debug */
180	u8 signal_strength_dbg; /* for debug */	180	u8 signal_strength_dbg; /* for debug */
181	s8 rssi;	181	s8 rssi;

drivers/staging/r8188eu/include/rtw_xmit.h+2−2

@@ -116,7 +116,7 @@ struct pkt_attrib { · 115 unmodified lines
116	u32 last_txcmdsz;	116	u32 last_txcmdsz;
117	u8 nr_frags;	117	u8 nr_frags;
118	u8 encrypt; /* when 0 indicate no encrypt. when non-zero,	118	u8 encrypt; /* when 0 indicate no encrypt. when non-zero,
119	* indicate the encrypt algorith */	119	* indicate the encrypt algorithm */
120	u8 iv_len;	120	u8 iv_len;
121	u8 icv_len;	121	u8 icv_len;
122	u8 iv[18];	122	u8 iv[18];
@@ -351,7 +351,7 @@ s32 rtw_txframes_pending(struct adapter *padapter); · 228 unmodified lines
351	s32 rtw_txframes_sta_ac_pending(struct adapter *padapter,	351	s32 rtw_txframes_sta_ac_pending(struct adapter *padapter,
352	struct pkt_attrib *pattrib);	352	struct pkt_attrib *pattrib);
353	void rtw_init_hwxmits(struct hw_xmit *phwxmit, int entry);	353	void rtw_init_hwxmits(struct hw_xmit *phwxmit, int entry);
354	s32 _rtw_init_xmit_priv(struct xmit_priv pxmitpriv, struct adapter padapter);	354	int _rtw_init_xmit_priv(struct xmit_priv pxmitpriv, struct adapter padapter);
355	void _rtw_free_xmit_priv(struct xmit_priv *pxmitpriv);	355	void _rtw_free_xmit_priv(struct xmit_priv *pxmitpriv);
356	int rtw_alloc_hwxmits(struct adapter *padapter);	356	int rtw_alloc_hwxmits(struct adapter *padapter);
357	void rtw_free_hwxmits(struct adapter *padapter);	357	void rtw_free_hwxmits(struct adapter *padapter);

drivers/staging/r8188eu/include/sta_info.h+9−9

drivers/staging/r8188eu/include/wifi.h+6−71

 #define _PWRMGT_	BIT(12)
 #define _MORE_DATA_	BIT(13)
 #define _PRIVACY_	BIT(14)
-#define _ORDER_		BIT(15)
 #define SetToDs(pbuf)	\
 	*(__le16 *)(pbuf) |= cpu_to_le16(_TO_DS_)
 #define SetPrivacy(pbuf)	\
 	*(__le16 *)(pbuf) |= cpu_to_le16(_PRIVACY_)
-#define GetPrivacy(pbuf)					\
-	(((*(__le16 *)(pbuf)) & cpu_to_le16(_PRIVACY_)) != 0)
 #define GetFrameType(pbuf)				\
 	(le16_to_cpu(*(__le16 *)(pbuf)) & (BIT(3) | BIT(2)))
 		*(__le16 *)(pbuf) |= cpu_to_le16(type); \
 	} while (0)
-#define GetTupleCache(pbuf)			\
-	(cpu_to_le16(*(unsigned short *)((size_t)(pbuf) + 22)))
-#define SetFragNum(pbuf, num) \
-	do {    \
-		*(unsigned short *)((size_t)(pbuf) + 22) = \
-			((*(unsigned short *)((size_t)(pbuf) + 22)) &	\
-			le16_to_cpu(~(0x000f))) | \
-			cpu_to_le16(0x0f & (num));     \
-	} while (0)
 #define SetSeqNum(pbuf, num) \
 	do {    \
 		*(__le16 *)((size_t)(pbuf) + 22) = \
 #define GetAMsdu(pbuf) (((le16_to_cpu(*(__le16 *)pbuf)) >> 7) & 0x1)
-#define SetAMsdu(pbuf, amsdu)	\
-	*(__le16 *)(pbuf) |= cpu_to_le16((amsdu & 1) << 7)
-#define GetTid(pbuf)	(le16_to_cpu(*(__le16 *)((size_t)(pbuf) +	\
-			(((GetToDs(pbuf)<<1) | GetFrDs(pbuf)) == 3 ?	\
-			30 : 24))) & 0x000f)
 #define GetAddr1Ptr(pbuf)	((unsigned char *)((size_t)(pbuf) + 4))
 #define GetAddr2Ptr(pbuf)	((unsigned char *)((size_t)(pbuf) + 10))
 #define GetAddr4Ptr(pbuf)	((unsigned char *)((size_t)(pbuf) + 24))
-static inline bool IS_MCAST(unsigned char *da)
-{
-	return (*da) & 0x01;
-}
-static inline unsigned char *get_da(unsigned char *pframe)
-{
-	unsigned char	*da;
-	unsigned int to_fr_ds = (GetToDs(pframe) << 1) | GetFrDs(pframe);
-	switch (to_fr_ds) {
-	case 0x00:	/*  ToDs=0, FromDs=0 */
-		da = GetAddr1Ptr(pframe);
-		break;
-	case 0x01:	/*  ToDs=0, FromDs=1 */
-		da = GetAddr1Ptr(pframe);
-		break;
-	case 0x02:	/*  ToDs=1, FromDs=0 */
-		da = GetAddr3Ptr(pframe);
-		break;
-	default:	/*  ToDs=1, FromDs=1 */
-		da = GetAddr3Ptr(pframe);
-		break;
-	}
-	return da;
-}
 static inline unsigned char *get_sa(unsigned char *pframe)
 {
 	unsigned char	*sa;
 				Below is the definition for 802.11n
 ------------------------------------------------------------------------------*/
-#define SetOrderBit(pbuf)	\
-	do	{	\
-		*(unsigned short *)(pbuf) |= cpu_to_le16(_ORDER_); \
-	} while (0)
-#define GetOrderBit(pbuf)			\
-	(((*(unsigned short *)(pbuf)) & le16_to_cpu(_ORDER_)) != 0)
 /**
  * struct rtw_ieee80211_bar - HT Block Ack Request
  *
 	struct AC_param	ac_param[4];
 } __packed;
-struct ADDBA_request {
-	unsigned char	action_code;
-	unsigned char	dialog_token;
-	__le16	BA_para_set;
-	__le16	BA_timeout_value;
-	__le16	BA_starting_seqctrl;
-} __packed;
 #define MAX_AMPDU_FACTOR_64K	3
 /* Spatial Multiplexing Power Save Modes */
 #define	P2P_WILDCARD_SSID_LEN			7
-/* default value, used when: (1)p2p disabed or (2)p2p enabled
+/* default value, used when: (1)p2p disabled or (2)p2p enabled
  * but only do 1 scan phase */
 #define	P2P_FINDPHASE_EX_NONE		0
 /*  used when p2p enabled and want to do 1 scan phase and
 	P2P_STATE_TX_PROVISION_DIS_REQ = 6,
 	P2P_STATE_RX_PROVISION_DIS_RSP = 7,
 	P2P_STATE_RX_PROVISION_DIS_REQ = 8,
-	/* Doing the group owner negoitation handshake */
+	/* Doing the group owner negotiation handshake */
 	P2P_STATE_GONEGO_ING = 9,
-	/* finish the group negoitation handshake with success */
+	/* finish the group negotiation handshake with success */
 	P2P_STATE_GONEGO_OK = 10,
-	/* finish the group negoitation handshake with failure */
+	/* finish the group negotiation handshake with failure */
 	P2P_STATE_GONEGO_FAIL = 11,
 	/* receiving the P2P Inviation request and match with the profile. */
 	P2P_STATE_RECV_INVITE_REQ_MATCH = 12,
 	P2P_STATE_RECV_INVITE_REQ_JOIN = 19,
 	/* recveing the P2P Inviation response with failure */
 	P2P_STATE_RX_INVITE_RESP_FAIL = 20,
-	/* receiving p2p negoitation response with information is not available */
+	/* receiving p2p negotiation response with information is not available */
 	P2P_STATE_RX_INFOR_NOREADY = 21,
-	/* sending p2p negoitation response with information is not available */
+	/* sending p2p negotiation response with information is not available */
 	P2P_STATE_TX_INFOR_NOREADY = 22,
 };

drivers/staging/r8188eu/include/wlan_bssdef.h+0−51

@@ -17,14 +17,6 @@ struct ndis_802_11_ssid { · 16 unmodified lines
17	u8 Ssid[32];	17	u8 Ssid[32];
18	};	18	};
19		19
20	enum NDIS_802_11_NETWORK_TYPE {
21	Ndis802_11FH,
22	Ndis802_11DS,
23	Ndis802_11OFDM5,
24	Ndis802_11OFDM24,
25	Ndis802_11NetworkTypeMax /* dummy upper bound */
26	};
27
28	struct ndis_802_11_config_fh {	20	struct ndis_802_11_config_fh {
29	u32 Length; /* Length of structure */	21	u32 Length; /* Length of structure */
30	u32 HopPattern; /* As defined by 802.11, MSB set */	22	u32 HopPattern; /* As defined by 802.11, MSB set */
@@ -185,20 +177,6 @@ struct ndis_802_11_status_ind { · 154 unmodified lines
185	/* MIC check time, 60 seconds. */	177	/* MIC check time, 60 seconds. */
186	#define MIC_CHECK_TIME 60000000	178	#define MIC_CHECK_TIME 60000000
187		179
188	struct ndis_802_11_auth_evt {
189	struct ndis_802_11_status_ind Status;
190	struct ndis_802_11_auth_req Request[1];
191	};
192
193	struct ndis_802_11_test {
194	u32 Length;
195	u32 Type;
196	union {
197	struct ndis_802_11_auth_evt AuthenticationEvent;
198	NDIS_802_11_RSSI RssiTrigger;
199	} tt;
200	};
201
202	#ifndef Ndis802_11APMode	180	#ifndef Ndis802_11APMode
203	#define Ndis802_11APMode (Ndis802_11InfrastructureMax+1)	181	#define Ndis802_11APMode (Ndis802_11InfrastructureMax+1)
204	#endif	182	#endif
@@ -233,7 +211,6 @@ struct wlan_bssid_ex { · 28 unmodified lines
233	struct ndis_802_11_ssid Ssid;	211	struct ndis_802_11_ssid Ssid;
234	u32 Privacy;	212	u32 Privacy;
235	NDIS_802_11_RSSI Rssi;/* in dBM,raw data ,get from PHY) */	213	NDIS_802_11_RSSI Rssi;/* in dBM,raw data ,get from PHY) */
236	enum NDIS_802_11_NETWORK_TYPE NetworkTypeInUse;
237	struct ndis_802_11_config Configuration;	214	struct ndis_802_11_config Configuration;
238	enum ndis_802_11_network_infra InfrastructureMode;	215	enum ndis_802_11_network_infra InfrastructureMode;
239	unsigned char SupportedRates[NDIS_802_11_LENGTH_RATES_EX];	216	unsigned char SupportedRates[NDIS_802_11_LENGTH_RATES_EX];
@@ -288,34 +265,6 @@ enum UAPSD_MAX_SP { · 48 unmodified lines
288	#define NUM_PRE_AUTH_KEY 16	265	#define NUM_PRE_AUTH_KEY 16
289	#define NUM_PMKID_CACHE NUM_PRE_AUTH_KEY	266	#define NUM_PMKID_CACHE NUM_PRE_AUTH_KEY
290		267
291	/*
292	* WPA2
293	*/
294
295	struct pmkid_candidate {
296	unsigned char BSSID[ETH_ALEN];
297	u32 Flags;
298	};
299
300	struct ndis_802_11_pmkid_list {
301	u32 Version; /* Version of the structure */
302	u32 NumCandidates; /* No. of pmkid candidates */
303	struct pmkid_candidate CandidateList[1];
304	};
305
306	struct ndis_802_11_auth_encrypt {
307	enum ndis_802_11_auth_mode AuthModeSupported;
308	enum ndis_802_11_wep_status EncryptStatusSupported;
309	};
310
311	struct ndis_802_11_cap {
312	u32 Length;
313	u32 Version;
314	u32 NoOfPMKIDs;
315	u32 NoOfAuthEncryptPairsSupported;
316	struct ndis_802_11_auth_encrypt AuthenticationEncryptionSupported[1];
317	};
318
319	u8 key_2char2num(u8 hch, u8 lch);	268	u8 key_2char2num(u8 hch, u8 lch);
320	u8 key_char2num(u8 ch);	269	u8 key_char2num(u8 ch);
321	u8 str_2char2num(u8 hch, u8 lch);	270	u8 str_2char2num(u8 hch, u8 lch);

drivers/staging/r8188eu/os_dep/ioctl_linux.c+10−18

 			     struct iw_request_info *info,
 			     union iwreq_data *wrqu, char *extra)
 {
-	int ret = 0;
 	struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 	struct iw_mlme *mlme = (struct iw_mlme *)extra;
 	switch (mlme->cmd) {
 	case IW_MLME_DEAUTH:
-		if (!rtw_set_802_11_disassociate(padapter))
+		rtw_set_802_11_disassociate(padapter);
-			ret = -1;
 		break;
 	case IW_MLME_DISASSOC:
-		if (!rtw_set_802_11_disassociate(padapter))
+		rtw_set_802_11_disassociate(padapter);
-			ret = -1;
 		break;
 	default:
 		return -EOPNOTSUPP;
 	}
-	return ret;
+	return 0;
 }
 static int rtw_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
 			      struct iw_request_info *a,
 			      union iwreq_data *wrqu, char *extra)
 {
-	int i, ret = 0;
+	int i;
 	struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 	u8 datarates[NumRates];
 	u32	target_rate = wrqu->bitrate.value;
 		}
 	}
-	if (rtw_setdatarate_cmd(padapter, datarates) != _SUCCESS)
+	return rtw_setdatarate_cmd(padapter, datarates);
-		ret = -1;
-	return ret;
 }
 static int rtw_wx_get_rate(struct net_device *dev,
 	u32 peer_channel = 0;
 	/*	Commented by Albert 20110304 */
-	/*	The input data contains two informations. */
+	/*	The input data contains two information. */
 	/*	1. First information is the MAC address which wants to formate with */
 	/*	2. Second information is the WPS PINCode or "pbc" string for push button method */
 	/*	Format: 00:E0:4C:00:00:05 */
 	uint p2pielen = 0, attr_contentlen = 0;
 	struct tx_invite_req_info *pinvite_req_info = &pwdinfo->invitereq_info;
-	/*	The input data contains two informations. */
+	/*	The input data contains two information items. */
 	/*	1. First information is the P2P device address which you want to send to. */
 	/*	2. Second information is the group id which combines with GO's mac address, space and GO's ssid. */
 	/*	Command line sample: iwpriv wlan0 p2p_set invite ="00:11:22:33:44:55 00:E0:4C:00:00:05 DIRECT-xy" */
 	u8 *p2pie;
 	uint p2pielen = 0, attr_contentlen = 0;
-	/*	The input data contains two informations. */
+	/*	The input data contains two information items. */
 	/*	1. First information is the MAC address which wants to issue the provisioning discovery request frame. */
 	/*	2. Second information is the WPS configuration method which wants to discovery */
 	/*	Format: 00:E0:4C:00:00:05_display */
 			       struct iw_request_info *info,
 			       union iwreq_data *wrqu, char *extra)
 {
-	int ret = 0;
 	if (!memcmp(extra, "enable =", 7)) {
 		rtw_wext_p2p_enable(dev, info, wrqu, &extra[7]);
 	} else if (!memcmp(extra, "setDN =", 6)) {
 		rtw_p2p_set_persistent(dev, info, wrqu, &extra[11]);
 	}
-	return ret;
+	return 0;
 }
 static int rtw_p2p_get2(struct net_device *dev,
 		if ((_VENDOR_SPECIFIC_IE_ == probereq_wpsie[0]) &&
 		    (!memcmp(&probereq_wpsie[2], wps_oui, 4))) {
-			cp_sz = probereq_wpsie_len > MAX_WPS_IE_LEN ? MAX_WPS_IE_LEN : probereq_wpsie_len;
+			cp_sz = min(probereq_wpsie_len, MAX_WPS_IE_LEN);
 			pmlmepriv->wps_probe_req_ie_len = 0;
 			kfree(pmlmepriv->wps_probe_req_ie);

drivers/staging/r8188eu/os_dep/os_intfs.c+15−26

 	return pnetdev;
 }
-u32 rtw_start_drv_threads(struct adapter *padapter)
+int rtw_start_drv_threads(struct adapter *padapter)
 {
-	u32 _status = _SUCCESS;
 	padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
 	if (IS_ERR(padapter->cmdThread))
-		_status = _FAIL;
+		return PTR_ERR(padapter->cmdThread);
-	else
-		/* wait for rtw_cmd_thread() to start running */
-		wait_for_completion(&padapter->cmdpriv.start_cmd_thread);
-	return _status;
+	/* wait for rtw_cmd_thread() to start running */
+	wait_for_completion(&padapter->cmdpriv.start_cmd_thread);
+	return 0;
 }
 void rtw_stop_drv_threads(struct adapter *padapter)
 	pmlmepriv->htpriv.ampdu_enable = false;/* set to disabled */
 	/* security_priv */
-	psecuritypriv->binstallGrpkey = _FAIL;
+	psecuritypriv->binstallGrpkey = false;
 	psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt;
 	psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt;
 	psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
 	padapter->bShowGetP2PState = 1;
 }
-u8 rtw_reset_drv_sw(struct adapter *padapter)
+void rtw_reset_drv_sw(struct adapter *padapter)
 {
 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 	padapter->mlmeextpriv.sitesurvey_res.state = SCAN_DISABLE;
 	rtw_set_signal_stat_timer(&padapter->recvpriv);
-	return _SUCCESS;
 }
 u8 rtw_init_drv_sw(struct adapter *padapter)
 {
-	if ((rtw_init_cmd_priv(&padapter->cmdpriv)) == _FAIL) {
+	if (rtw_init_cmd_priv(&padapter->cmdpriv)) {
 		dev_err(dvobj_to_dev(padapter->dvobj), "rtw_init_cmd_priv failed\n");
 		return _FAIL;
 	}
 	padapter->cmdpriv.padapter = padapter;
-	if ((rtw_init_evt_priv(&padapter->evtpriv)) == _FAIL) {
+	if (rtw_init_evt_priv(&padapter->evtpriv)) {
 		dev_err(dvobj_to_dev(padapter->dvobj), "rtw_init_evt_priv failed\n");
 		goto free_cmd_priv;
 	}
-	if (rtw_init_mlme_priv(padapter) == _FAIL) {
+	if (rtw_init_mlme_priv(padapter)) {
 		dev_err(dvobj_to_dev(padapter->dvobj), "rtw_init_mlme_priv failed\n");
 		goto free_evt_priv;
 	}
 	init_mlme_ext_priv(padapter);
-	if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL) {
+	if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter)) {
 		dev_err(dvobj_to_dev(padapter->dvobj), "_rtw_init_xmit_priv failed\n");
 		goto free_mlme_ext;
 	}
 		goto free_xmit_priv;
 	}
-	if (_rtw_init_sta_priv(&padapter->stapriv) == _FAIL) {
+	if (_rtw_init_sta_priv(&padapter->stapriv)) {
 		dev_err(dvobj_to_dev(padapter->dvobj), "_rtw_init_sta_priv failed\n");
 		goto free_recv_priv;
 	}
 	_cancel_timer_ex(&padapter->recvpriv.signal_stat_timer);
 }
-u8 rtw_free_drv_sw(struct adapter *padapter)
+void rtw_free_drv_sw(struct adapter *padapter)
 {
 	/* we can call rtw_p2p_enable here, but: */
 	/*  1. rtw_p2p_enable may have IO operation */
 	/*  clear pbuddystruct adapter to avoid access wrong pointer. */
 	if (padapter->pbuddy_adapter)
 		padapter->pbuddy_adapter->pbuddy_adapter = NULL;
-	return _SUCCESS;
 }
 void netdev_br_init(struct net_device *netdev)
 	if (!padapter->bup) {
 		padapter->bDriverStopped = false;
 		padapter->bSurpriseRemoved = false;
-		padapter->bCardDisableWOHSM = false;
 		status = rtw_hal_init(padapter);
 		if (status == _FAIL)
 		netdev_dbg(pnetdev, "MAC Address = %pM\n", pnetdev->dev_addr);
-		status = rtw_start_drv_threads(padapter);
+		if (rtw_start_drv_threads(padapter)) {
-		if (status == _FAIL) {
 			pr_info("Initialize driver software resource Failed!\n");
 			goto netdev_open_error;
 		}
 	padapter->bDriverStopped = false;
 	padapter->bSurpriseRemoved = false;
-	padapter->bCardDisableWOHSM = false;
 	status = rtw_hal_init(padapter);
 	if (status == _FAIL)
 void rtw_ips_pwr_down(struct adapter *padapter)
 {
-	padapter->bCardDisableWOHSM = true;
 	padapter->net_closed = true;
 	rtw_led_control(padapter, LED_CTL_POWER_OFF);
 	rtw_ips_dev_unload(padapter);
-	padapter->bCardDisableWOHSM = false;
 }
 static void rtw_fifo_cleanup(struct adapter *adapter)

drivers/staging/rtl8192e/TODO+17−1

@@ -1,2 +1,18 @@
1	* merge into drivers/net/wireless/rtllib/rtl8192e	1	To-do list:
		2
		3	* merge into drivers/net/wireless/realtek/rtlwifi/rtl8192*
2	* clean up function naming	4	* clean up function naming
		5	* Correct the coding style according to Linux guidelines; please read the document
		6	at https://www.kernel.org/doc/html/latest/process/coding-style.html.
		7	* Remove unnecessary debugging/printing macros; for those that are still needed
		8	use the proper kernel API (pr_debug(), dev_dbg(), netdev_dbg()).
		9	* Remove dead code such as unusued functions, variables, fields, etc..
		10	* Use in-kernel API and remove unnecessary wrappers where possible.
		11	* Fix bugs due to code that sleeps in atomic context.
		12	* Remove the HAL layer and migrate its functionality into the relevant parts of
		13	the driver.
		14	* Switch to use LIB80211.
		15	* Switch to use MAC80211.
		16	* Switch to use CFG80211.
		17	* Improve the error handling of various functions, particularly those that use
		18	existing kernel APIs.

drivers/staging/rtl8192e/rtl8192e/r8190P_def.h+0−15

@@ -154,21 +154,6 @@ struct tx_fwinfo_8190pci { · 153 unmodified lines
154		154
155	};	155	};
156		156
157	struct log_int_8190 {
158	u32 nIMR_COMDOK;
159	u32 nIMR_MGNTDOK;
160	u32 nIMR_HIGH;
161	u32 nIMR_VODOK;
162	u32 nIMR_VIDOK;
163	u32 nIMR_BEDOK;
164	u32 nIMR_BKDOK;
165	u32 nIMR_ROK;
166	u32 nIMR_RCOK;
167	u32 nIMR_TBDOK;
168	u32 nIMR_BDOK;
169	u32 nIMR_RXFOVW;
170	};
171
172	struct phy_ofdm_rx_status_rxsc_sgien_exintfflag {	157	struct phy_ofdm_rx_status_rxsc_sgien_exintfflag {
173	u8 reserved:4;	158	u8 reserved:4;
174	u8 rxsc:2;	159	u8 rxsc:2;

drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c+22−33

 		u8 acm = pAciAifsn->f.acm;
 		u8 AcmCtrl = rtl92e_readb(dev, AcmHwCtrl);
-		AcmCtrl = AcmCtrl | ((priv->AcmMethod == 2) ? 0x0 : 0x1);
 		if (acm) {
 			switch (eACI) {
 			case AC0_BE:
 	priv->rf_chip = RF_8256;
-	if (priv->RegChannelPlan == 0xf)
+	if (priv->reg_chnl_plan == 0xf)
 		priv->ChannelPlan = priv->eeprom_ChannelPlan;
 	else
-		priv->ChannelPlan = priv->RegChannelPlan;
+		priv->ChannelPlan = priv->reg_chnl_plan;
 	if (priv->eeprom_vid == 0x1186 &&  priv->eeprom_did == 0x3304)
 		priv->CustomerID =  RT_CID_DLINK;
 			priv->ChannelPlan = 0x0;
 		break;
 	case EEPROM_CID_Nettronix:
-		priv->ScanDelay = 100;
 		priv->CustomerID = RT_CID_Nettronix;
 		break;
 	case EEPROM_CID_Pronet:
 start:
 	rtl92e_reset_desc_ring(dev);
 	priv->Rf_Mode = RF_OP_By_SW_3wire;
-	if (priv->ResetProgress == RESET_TYPE_NORESET) {
+	if (priv->rst_progress == RESET_TYPE_NORESET) {
 		rtl92e_writeb(dev, ANAPAR, 0x37);
 		mdelay(500);
 	}
 	priv->pFirmware->status = FW_STATUS_0_INIT;
-	if (priv->RegRfOff)
-		priv->rtllib->rf_power_state = rf_off;
 	ulRegRead = rtl92e_readl(dev, CPU_GEN);
 	if (priv->pFirmware->status == FW_STATUS_0_INIT)
 		ulRegRead |= CPU_GEN_SYSTEM_RESET;
 	}
 	priv->LoopbackMode = RTL819X_NO_LOOPBACK;
-	if (priv->ResetProgress == RESET_TYPE_NORESET) {
+	if (priv->rst_progress == RESET_TYPE_NORESET) {
 		ulRegRead = rtl92e_readl(dev, CPU_GEN);
 		if (priv->LoopbackMode == RTL819X_NO_LOOPBACK)
 			ulRegRead = (ulRegRead & CPU_GEN_NO_LOOPBACK_MSK) |
 	rtl92e_writeb(dev, ACK_TIMEOUT, 0x30);
-	if (priv->ResetProgress == RESET_TYPE_NORESET)
+	if (priv->rst_progress == RESET_TYPE_NORESET)
 		rtl92e_set_wireless_mode(dev, priv->rtllib->mode);
 	rtl92e_cam_reset(dev);
 	{
 		}
 	}
-	if (priv->ResetProgress == RESET_TYPE_NORESET) {
+	if (priv->rst_progress == RESET_TYPE_NORESET) {
 		rtStatus = rtl92e_config_phy(dev);
 		if (!rtStatus) {
 			netdev_info(dev, "RF Config failed\n");
 	rtl92e_writeb(dev, 0x87, 0x0);
-	if (priv->RegRfOff) {
+	if (priv->rtllib->rf_off_reason > RF_CHANGE_BY_PS) {
-		rtl92e_set_rf_state(dev, rf_off, RF_CHANGE_BY_SW);
-	} else if (priv->rtllib->rf_off_reason > RF_CHANGE_BY_PS) {
 		rtl92e_set_rf_state(dev, rf_off, priv->rtllib->rf_off_reason);
 	} else if (priv->rtllib->rf_off_reason >= RF_CHANGE_BY_IPS) {
 		rtl92e_set_rf_state(dev, rf_off, priv->rtllib->rf_off_reason);
 	else
 		priv->Rf_Mode = RF_OP_By_SW_3wire;
-	if (priv->ResetProgress == RESET_TYPE_NORESET) {
+	if (priv->rst_progress == RESET_TYPE_NORESET) {
 		rtl92e_dm_init_txpower_tracking(dev);
 		if (priv->IC_Cut >= IC_VersionCut_D) {
 			}
 			priv->CCKPresentAttentuation_40Mdefault = 0;
 			priv->CCKPresentAttentuation_difference = 0;
-			priv->CCKPresentAttentuation =
+			priv->cck_present_attn =
 				  priv->CCKPresentAttentuation_20Mdefault;
 			priv->btxpower_tracking = false;
 		}
 		reg = rtl92e_readl(dev, RCR);
 		if (priv->rtllib->state == RTLLIB_LINKED) {
-			if (ieee->IntelPromiscuousModeInfo.bPromiscuousOn)
+			if (ieee->intel_promiscuous_md_info.promiscuous_on)
 				;
 			else
 				priv->ReceiveConfig = reg |= RCR_CBSSID;
 	if (cb_desc->bHwSec) {
 		static u8 tmp;
-		if (!tmp) {
+		if (!tmp)
 			tmp = 1;
-		}
 		switch (priv->rtllib->pairwise_key_type) {
 		case KEY_TYPE_WEP40:
 		case KEY_TYPE_WEP104:
 							  cb_desc->priority);
 	pdesc->TxFWInfoSize = sizeof(struct tx_fwinfo_8190pci);
-	pdesc->DISFB = cb_desc->bTxDisableRateFallBack;
+	pdesc->DISFB = cb_desc->tx_dis_rate_fallback;
-	pdesc->USERATE = cb_desc->bTxUseDriverAssingedRate;
+	pdesc->USERATE = cb_desc->tx_use_drv_assinged_rate;
 	pdesc->FirstSeg = 1;
 	pdesc->LastSeg = 1;
 	if (!reset) {
 		mdelay(150);
-		priv->bHwRfOffAction = 2;
+		priv->hw_rf_off_action = 2;
 		if (!priv->rtllib->bSupportRemoteWakeUp) {
 			rtl92e_set_rf_off(dev);
 	for (i = 0; i < MAX_QUEUE_SIZE; i++)
 		skb_queue_purge(&priv->rtllib->skb_waitQ[i]);
-	for (i = 0; i < MAX_QUEUE_SIZE; i++)
-		skb_queue_purge(&priv->rtllib->skb_aggQ[i]);
 	skb_queue_purge(&priv->skb_queue);
 }
 {
 	struct r8192_priv *priv = rtllib_priv(dev);
 	struct rtllib_device *ieee = priv->rtllib;
-	u8 *pMcsRate = ieee->dot11HTOperationalRateSet;
+	u8 *pMcsRate = ieee->dot11ht_oper_rate_set;
 	u32 ratr_value = 0;
 	u16 rate_config = 0;
 	u8 rate_index = 0;
 		break;
 	case IEEE_N_24G:
 	case IEEE_N_5G:
-		if (ieee->pHTInfo->peer_mimo_ps == 0) {
+		if (ieee->ht_info->peer_mimo_ps == 0) {
 			ratr_value &= 0x0007F007;
 		} else {
 			if (priv->rf_type == RF_1T2R)
 		break;
 	}
 	ratr_value &= 0x0FFFFFFF;
-	if (ieee->pHTInfo->cur_tx_bw40mhz &&
+	if (ieee->ht_info->cur_tx_bw40mhz &&
-	    ieee->pHTInfo->bCurShortGI40MHz)
+	    ieee->ht_info->bCurShortGI40MHz)
 		ratr_value |= 0x80000000;
-	else if (!ieee->pHTInfo->cur_tx_bw40mhz &&
+	else if (!ieee->ht_info->cur_tx_bw40mhz &&
-		  ieee->pHTInfo->bCurShortGI20MHz)
+		  ieee->ht_info->bCurShortGI20MHz)
 		ratr_value |= 0x80000000;
 	rtl92e_writel(dev, RATR0+rate_index*4, ratr_value);
 	rtl92e_writeb(dev, UFWP, 1);
 	SlotIndex = (priv->SilentResetRxSlotIndex++)%SilentResetRxSoltNum;
-	if (priv->RxCounter == RegRxCounter) {
+	if (priv->rx_ctr == RegRxCounter) {
 		priv->SilentResetRxStuckEvent[SlotIndex] = 1;
 		for (i = 0; i < SilentResetRxSoltNum; i++)
 		priv->SilentResetRxStuckEvent[SlotIndex] = 0;
 	}
-	priv->RxCounter = RegRxCounter;
+	priv->rx_ctr = RegRxCounter;
 	return bStuck;
 }

drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c+23−27

 		rtStatus  = rtl92e_check_bb_and_rf(dev,
 						   (enum hw90_block)eCheckItem,
 						   (enum rf90_radio_path)0);
-		if (!rtStatus) {
+		if (!rtStatus)
 			return rtStatus;
-		}
 	}
 	rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bCCKEn|bOFDMEn, 0x0);
 	_rtl92e_phy_config_bb(dev, BaseBand_Config_PHY_REG);
 	switch (priv->CurrentChannelBW) {
 	case HT_CHANNEL_WIDTH_20:
-		priv->CCKPresentAttentuation =
+		priv->cck_present_attn =
 			priv->CCKPresentAttentuation_20Mdefault +
 			    priv->CCKPresentAttentuation_difference;
-		if (priv->CCKPresentAttentuation >
+		if (priv->cck_present_attn >
 		    (CCKTxBBGainTableLength-1))
-			priv->CCKPresentAttentuation =
+			priv->cck_present_attn =
 					 CCKTxBBGainTableLength-1;
-		if (priv->CCKPresentAttentuation < 0)
+		if (priv->cck_present_attn < 0)
-			priv->CCKPresentAttentuation = 0;
+			priv->cck_present_attn = 0;
 		if (priv->rtllib->current_network.channel == 14 &&
 		    !priv->bcck_in_ch14) {
 		break;
 	case HT_CHANNEL_WIDTH_20_40:
-		priv->CCKPresentAttentuation =
+		priv->cck_present_attn =
 			priv->CCKPresentAttentuation_40Mdefault +
 			priv->CCKPresentAttentuation_difference;
-		if (priv->CCKPresentAttentuation >
+		if (priv->cck_present_attn >
 		    (CCKTxBBGainTableLength - 1))
-			priv->CCKPresentAttentuation =
+			priv->cck_present_attn =
 					 CCKTxBBGainTableLength-1;
-		if (priv->CCKPresentAttentuation < 0)
+		if (priv->cck_present_attn < 0)
-			priv->CCKPresentAttentuation = 0;
+			priv->cck_present_attn = 0;
 		if (priv->rtllib->current_network.channel == 14 &&
 		    !priv->bcck_in_ch14) {
 				       enum rt_rf_power_state rf_power_state)
 {
 	struct r8192_priv *priv = rtllib_priv(dev);
-	struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
+	struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *)
-					(&(priv->rtllib->PowerSaveControl));
+					(&priv->rtllib->pwr_save_ctrl);
 	bool bResult = true;
 	u8	i = 0, QueueID = 0;
 	struct rtl8192_tx_ring  *ring = NULL;
 		switch (rf_power_state) {
 		case rf_on:
 			if ((priv->rtllib->rf_power_state == rf_off) &&
-			     RT_IN_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC)) {
+			     RT_IN_PS_LEVEL(psc, RT_RF_OFF_LEVL_HALT_NIC)) {
 				bool rtstatus;
 				u32 InitilizeCount = 3;
 				do {
 					InitilizeCount--;
-					priv->RegRfOff = false;
 					rtstatus = rtl92e_enable_nic(dev);
 				} while (!rtstatus && (InitilizeCount > 0));
 					return false;
 				}
-				RT_CLEAR_PS_LEVEL(pPSC,
+				RT_CLEAR_PS_LEVEL(psc,
 						  RT_RF_OFF_LEVL_HALT_NIC);
 			} else {
 				rtl92e_writeb(dev, ANAPAR, 0x37);
 				mdelay(1);
 				rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1,
 						 0x4, 0x1);
-				priv->bHwRfOffAction = 0;
+				priv->hw_rf_off_action = 0;
 				rtl92e_set_bb_reg(dev, rFPGA0_XA_RFInterfaceOE,
 						  BIT4, 0x1);
 					i++;
 				}
-				if (i >= MAX_DOZE_WAITING_TIMES_9x) {
+				if (i >= MAX_DOZE_WAITING_TIMES_9x)
 					break;
-				}
 			}
 			rtl92e_set_rf_off(dev);
 			break;
 					i++;
 				}
-				if (i >= MAX_DOZE_WAITING_TIMES_9x) {
+				if (i >= MAX_DOZE_WAITING_TIMES_9x)
 					break;
-				}
 			}
-			if (pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_HALT_NIC &&
+			if (psc->RegRfPsLevel & RT_RF_OFF_LEVL_HALT_NIC &&
-			    !RT_IN_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC)) {
+			    !RT_IN_PS_LEVEL(psc, RT_RF_OFF_LEVL_HALT_NIC)) {
 				rtl92e_disable_nic(dev);
-				RT_SET_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
+				RT_SET_PS_LEVEL(psc, RT_RF_OFF_LEVL_HALT_NIC);
-			} else if (!(pPSC->RegRfPsLevel &
+			} else if (!(psc->RegRfPsLevel &
 				   RT_RF_OFF_LEVL_HALT_NIC)) {
 				rtl92e_set_rf_off(dev);
 			}
 	bool bResult = false;
 	if (rf_power_state == priv->rtllib->rf_power_state &&
-	    priv->bHwRfOffAction == 0) {
+	    priv->hw_rf_off_action == 0) {
 		return bResult;
 	}

drivers/staging/rtl8192e/rtl8192e/rtl_cam.c+20−23

 {
 	u32 ulcommand = 0;
-	ulcommand |= BIT31|BIT30;
+	ulcommand |= BIT31 | BIT30;
 	rtl92e_writel(dev, RWCAM, ulcommand);
 }
 		SECR_value |= SCR_TxUseDK;
 	}
 	ieee->hwsec_active = 1;
-	if ((ieee->pHTInfo->iot_action & HT_IOT_ACT_PURE_N_MODE) || !hwwep) {
+	if ((ieee->ht_info->iot_action & HT_IOT_ACT_PURE_N_MODE) || !hwwep) {
 		ieee->hwsec_active = 0;
 		SECR_value &= ~SCR_RxDecEnable;
 	}
 	enum rt_rf_power_state rt_state;
 	rt_state = priv->rtllib->rf_power_state;
-	if (priv->rtllib->PowerSaveControl.bInactivePs) {
+	if (rt_state == rf_off) {
-		if (rt_state == rf_off) {
+		if (priv->rtllib->rf_off_reason > RF_CHANGE_BY_IPS) {
-			if (priv->rtllib->rf_off_reason > RF_CHANGE_BY_IPS) {
+			netdev_warn(dev, "%s(): RF is OFF.\n",
-				netdev_warn(dev, "%s(): RF is OFF.\n",
+				    __func__);
-					    __func__);
+			return;
-				return;
-			}
-			mutex_lock(&priv->rtllib->ips_mutex);
-			rtl92e_ips_leave(dev);
-			mutex_unlock(&priv->rtllib->ips_mutex);
 		}
+		mutex_lock(&priv->rtllib->ips_mutex);
+		rtl92e_ips_leave(dev);
+		mutex_unlock(&priv->rtllib->ips_mutex);
 	}
 	priv->rtllib->is_set_key = true;
 	if (EntryNo >= TOTAL_CAM_ENTRY) {
 	}
 	if (DefaultKey)
-		usConfig |= BIT15 | (KeyType<<2);
+		usConfig |= BIT15 | (KeyType << 2);
 	else
-		usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
+		usConfig |= BIT15 | (KeyType << 2) | KeyIndex;
 	for (i = 0; i < CAM_CONTENT_COUNT; i++) {
 		TargetCommand  = i + CAM_CONTENT_COUNT * EntryNo;
-		TargetCommand |= BIT31|BIT16;
+		TargetCommand |= BIT31 | BIT16;
 		if (i == 0) {
-			TargetContent = (u32)(*(MacAddr+0)) << 16 |
+			TargetContent = (u32)(*(MacAddr + 0)) << 16 |
-				(u32)(*(MacAddr+1)) << 24 |
+				(u32)(*(MacAddr + 1)) << 24 |
 				(u32)usConfig;
 			rtl92e_writel(dev, WCAMI, TargetContent);
 			rtl92e_writel(dev, RWCAM, TargetCommand);
 		} else if (i == 1) {
-			TargetContent = (u32)(*(MacAddr+2)) |
+			TargetContent = (u32)(*(MacAddr + 2)) |
-				(u32)(*(MacAddr+3)) <<  8 |
+				(u32)(*(MacAddr + 3)) <<  8 |
-				(u32)(*(MacAddr+4)) << 16 |
+				(u32)(*(MacAddr + 4)) << 16 |
-				(u32)(*(MacAddr+5)) << 24;
+				(u32)(*(MacAddr + 5)) << 24;
 			rtl92e_writel(dev, WCAMI, TargetContent);
 			rtl92e_writel(dev, RWCAM, TargetCommand);
 		} else {
 			if (KeyContent != NULL) {
 				rtl92e_writel(dev, WCAMI,
-					      (u32)(*(KeyContent+i-2)));
+					      (u32)(*(KeyContent + i - 2)));
 				rtl92e_writel(dev, RWCAM, TargetCommand);
 				udelay(100);
 			}

drivers/staging/rtl8192e/rtl8192e/rtl_core.c+84−107

@@ -307,7 +307,7 @@ static void _rtl92e_update_cap(struct net_device *dev, u16 cap) · 306 unmodified lines
307	u8 cur_slot_time = priv->slot_time;	307	u8 cur_slot_time = priv->slot_time;
308		308
309	if ((cap & WLAN_CAPABILITY_SHORT_SLOT_TIME) &&	309	if ((cap & WLAN_CAPABILITY_SHORT_SLOT_TIME) &&
310	(!priv->rtllib->pHTInfo->current_rt2rt_long_slot_time)) {	310	(!priv->rtllib->ht_info->current_rt2rt_long_slot_time)) {
311	if (cur_slot_time != SHORT_SLOT_TIME) {	311	if (cur_slot_time != SHORT_SLOT_TIME) {
312	slot_time_val = SHORT_SLOT_TIME;	312	slot_time_val = SHORT_SLOT_TIME;
313	priv->rtllib->SetHwRegHandler(dev,	313	priv->rtllib->SetHwRegHandler(dev,
@@ -339,10 +339,10 @@ static void _rtl92e_update_beacon(void *data) · 25 unmodified lines
339	struct rtllib_device *ieee = priv->rtllib;	339	struct rtllib_device *ieee = priv->rtllib;
340	struct rtllib_network *net = &ieee->current_network;	340	struct rtllib_network *net = &ieee->current_network;
341		341
342	if (ieee->pHTInfo->bCurrentHTSupport)	342	if (ieee->ht_info->bCurrentHTSupport)
343	HT_update_self_and_peer_setting(ieee, net);	343	HT_update_self_and_peer_setting(ieee, net);
344	ieee->pHTInfo->current_rt2rt_long_slot_time = net->bssht.bd_rt2rt_long_slot_time;	344	ieee->ht_info->current_rt2rt_long_slot_time = net->bssht.bd_rt2rt_long_slot_time;
345	ieee->pHTInfo->RT2RT_HT_Mode = net->bssht.rt2rt_ht_mode;	345	ieee->ht_info->RT2RT_HT_Mode = net->bssht.rt2rt_ht_mode;
346	_rtl92e_update_cap(dev, net->capability);	346	_rtl92e_update_cap(dev, net->capability);
347	}	347	}
348		348
@@ -494,8 +494,8 @@ static void _rtl92e_prepare_beacon(struct tasklet_struct *t) · 145 unmodified lines
494	tcb_desc->queue_index = BEACON_QUEUE;	494	tcb_desc->queue_index = BEACON_QUEUE;
495	tcb_desc->data_rate = 2;	495	tcb_desc->data_rate = 2;
496	tcb_desc->RATRIndex = 7;	496	tcb_desc->RATRIndex = 7;
497	tcb_desc->bTxDisableRateFallBack = 1;	497	tcb_desc->tx_dis_rate_fallback = 1;
498	tcb_desc->bTxUseDriverAssingedRate = 1;	498	tcb_desc->tx_use_drv_assinged_rate = 1;
499	skb_push(pnewskb, priv->rtllib->tx_headroom);	499	skb_push(pnewskb, priv->rtllib->tx_headroom);
500		500
501	pdesc = &ring->desc[0];	501	pdesc = &ring->desc[0];
@@ -607,13 +607,13 @@ static void _rtl92e_refresh_support_rate(struct r8192_priv *priv) · 105 unmodified lines
607		607
608	if (ieee->mode == WIRELESS_MODE_N_24G \|\|	608	if (ieee->mode == WIRELESS_MODE_N_24G \|\|
609	ieee->mode == WIRELESS_MODE_N_5G) {	609	ieee->mode == WIRELESS_MODE_N_5G) {
610	memcpy(ieee->Regdot11HTOperationalRateSet,	610	memcpy(ieee->reg_dot11ht_oper_rate_set,
611	ieee->RegHTSuppRateSet, 16);	611	ieee->reg_ht_supp_rate_set, 16);
612	memcpy(ieee->Regdot11TxHTOperationalRateSet,	612	memcpy(ieee->reg_dot11tx_ht_oper_rate_set,
613	ieee->RegHTSuppRateSet, 16);	613	ieee->reg_ht_supp_rate_set, 16);
614		614
615	} else {	615	} else {
616	memset(ieee->Regdot11HTOperationalRateSet, 0, 16);	616	memset(ieee->reg_dot11ht_oper_rate_set, 0, 16);
617	}	617	}
618	}	618	}
619		619
@@ -642,19 +642,19 @@ static u8 _rtl92e_get_supported_wireless_mode(struct net_device *dev) · 22 unmodified lines
642	void rtl92e_set_wireless_mode(struct net_device *dev, u8 wireless_mode)	642	void rtl92e_set_wireless_mode(struct net_device *dev, u8 wireless_mode)
643	{	643	{
644	struct r8192_priv *priv = rtllib_priv(dev);	644	struct r8192_priv *priv = rtllib_priv(dev);
645	u8 bSupportMode = _rtl92e_get_supported_wireless_mode(dev);	645	u8 support_mode = _rtl92e_get_supported_wireless_mode(dev);
646		646
647	if ((wireless_mode == WIRELESS_MODE_AUTO) \|\|	647	if ((wireless_mode == WIRELESS_MODE_AUTO) \|\|
648	((wireless_mode & bSupportMode) == 0)) {	648	((wireless_mode & support_mode) == 0)) {
649	if (bSupportMode & WIRELESS_MODE_N_24G) {	649	if (support_mode & WIRELESS_MODE_N_24G) {
650	wireless_mode = WIRELESS_MODE_N_24G;	650	wireless_mode = WIRELESS_MODE_N_24G;
651	} else if (bSupportMode & WIRELESS_MODE_N_5G) {	651	} else if (support_mode & WIRELESS_MODE_N_5G) {
652	wireless_mode = WIRELESS_MODE_N_5G;	652	wireless_mode = WIRELESS_MODE_N_5G;
653	} else if ((bSupportMode & WIRELESS_MODE_A)) {	653	} else if ((support_mode & WIRELESS_MODE_A)) {
654	wireless_mode = WIRELESS_MODE_A;	654	wireless_mode = WIRELESS_MODE_A;
655	} else if ((bSupportMode & WIRELESS_MODE_G)) {	655	} else if ((support_mode & WIRELESS_MODE_G)) {
656	wireless_mode = WIRELESS_MODE_G;	656	wireless_mode = WIRELESS_MODE_G;
657	} else if ((bSupportMode & WIRELESS_MODE_B)) {	657	} else if ((support_mode & WIRELESS_MODE_B)) {
658	wireless_mode = WIRELESS_MODE_B;	658	wireless_mode = WIRELESS_MODE_B;
659	} else {	659	} else {
660	netdev_info(dev,	660	netdev_info(dev,
@@ -672,9 +672,9 @@ void rtl92e_set_wireless_mode(struct net_device *dev, u8 wireless_mode) · 11 unmodified lines
672		672
673	if ((wireless_mode == WIRELESS_MODE_N_24G) \|\|	673	if ((wireless_mode == WIRELESS_MODE_N_24G) \|\|
674	(wireless_mode == WIRELESS_MODE_N_5G)) {	674	(wireless_mode == WIRELESS_MODE_N_5G)) {
675	priv->rtllib->pHTInfo->bEnableHT = 1;	675	priv->rtllib->ht_info->enable_ht = 1;
676	} else {	676	} else {
677	priv->rtllib->pHTInfo->bEnableHT = 0;	677	priv->rtllib->ht_info->enable_ht = 0;
678	}	678	}
679	_rtl92e_refresh_support_rate(priv);	679	_rtl92e_refresh_support_rate(priv);
680	}	680	}
@@ -682,11 +682,10 @@ void rtl92e_set_wireless_mode(struct net_device *dev, u8 wireless_mode) · 1 unmodified line
682	static int _rtl92e_sta_up(struct net_device *dev, bool is_silent_reset)	682	static int _rtl92e_sta_up(struct net_device *dev, bool is_silent_reset)
683	{	683	{
684	struct r8192_priv *priv = rtllib_priv(dev);	684	struct r8192_priv *priv = rtllib_priv(dev);
685	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )	685	struct rt_pwr_save_ctrl psc = (struct rt_pwr_save_ctrl )
686	(&priv->rtllib->PowerSaveControl);	686	(&priv->rtllib->pwr_save_ctrl);
687	bool init_status;	687	bool init_status;
688		688
689	priv->bDriverIsGoingToUnload = false;
690	priv->bdisable_nic = false;	689	priv->bdisable_nic = false;
691		690
692	priv->up = 1;	691	priv->up = 1;
@@ -701,7 +700,7 @@ static int _rtl92e_sta_up(struct net_device *dev, bool is_silent_reset) · 8 unmodified lines
701	return -1;	700	return -1;
702	}	701	}
703		702
704	RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);	703	RT_CLEAR_PS_LEVEL(psc, RT_RF_OFF_LEVL_HALT_NIC);
705	priv->bfirst_init = false;	704	priv->bfirst_init = false;
706		705
707	if (priv->polling_timer_on == 0)	706	if (priv->polling_timer_on == 0)
@@ -724,7 +723,7 @@ static int _rtl92e_sta_down(struct net_device *dev, bool shutdownrf) · 16 unmodified lines
724	{	723	{
725	struct r8192_priv *priv = rtllib_priv(dev);	724	struct r8192_priv *priv = rtllib_priv(dev);
726	unsigned long flags = 0;	725	unsigned long flags = 0;
727	u8 RFInProgressTimeOut = 0;	726	u8 rf_in_progress_timeout = 0;
728		727
729	if (priv->up == 0)	728	if (priv->up == 0)
730	return -1;	729	return -1;
@@ -735,7 +734,6 @@ static int _rtl92e_sta_down(struct net_device *dev, bool shutdownrf) · 4 unmodified lines
735	if (priv->rtllib->state == RTLLIB_LINKED)	734	if (priv->rtllib->state == RTLLIB_LINKED)
736	rtl92e_leisure_ps_leave(dev);	735	rtl92e_leisure_ps_leave(dev);
737		736
738	priv->bDriverIsGoingToUnload = true;
739	priv->up = 0;	737	priv->up = 0;
740	priv->rtllib->ieee_up = 0;	738	priv->rtllib->ieee_up = 0;
741	priv->bfirst_after_down = true;	739	priv->bfirst_after_down = true;
@@ -757,12 +755,12 @@ static int _rtl92e_sta_down(struct net_device *dev, bool shutdownrf) · 15 unmodified lines
757	spin_lock_irqsave(&priv->rf_ps_lock, flags);	755	spin_lock_irqsave(&priv->rf_ps_lock, flags);
758	while (priv->rf_change_in_progress) {	756	while (priv->rf_change_in_progress) {
759	spin_unlock_irqrestore(&priv->rf_ps_lock, flags);	757	spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
760	if (RFInProgressTimeOut > 100) {	758	if (rf_in_progress_timeout > 100) {
761	spin_lock_irqsave(&priv->rf_ps_lock, flags);	759	spin_lock_irqsave(&priv->rf_ps_lock, flags);
762	break;	760	break;
763	}	761	}
764	mdelay(1);	762	mdelay(1);
765	RFInProgressTimeOut++;	763	rf_in_progress_timeout++;
766	spin_lock_irqsave(&priv->rf_ps_lock, flags);	764	spin_lock_irqsave(&priv->rf_ps_lock, flags);
767	}	765	}
768	priv->rf_change_in_progress = true;	766	priv->rf_change_in_progress = true;
@@ -821,10 +819,10 @@ static void _rtl92e_init_priv_handler(struct net_device *dev) · 52 unmodified lines
821	static void _rtl92e_init_priv_constant(struct net_device *dev)	819	static void _rtl92e_init_priv_constant(struct net_device *dev)
822	{	820	{
823	struct r8192_priv *priv = rtllib_priv(dev);	821	struct r8192_priv *priv = rtllib_priv(dev);
824	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )	822	struct rt_pwr_save_ctrl psc = (struct rt_pwr_save_ctrl )
825	&priv->rtllib->PowerSaveControl;	823	&priv->rtllib->pwr_save_ctrl;
826		824
827	pPSC->RegMaxLPSAwakeIntvl = 5;	825	psc->reg_max_lps_awake_intvl = 5;
828	}	826	}
829		827
830	static void _rtl92e_init_priv_variable(struct net_device *dev)	828	static void _rtl92e_init_priv_variable(struct net_device *dev)
@@ -832,15 +830,12 @@ static void _rtl92e_init_priv_variable(struct net_device *dev) · 1 unmodified line
832	struct r8192_priv *priv = rtllib_priv(dev);	830	struct r8192_priv *priv = rtllib_priv(dev);
833	u8 i;	831	u8 i;
834		832
835	priv->AcmMethod = eAcmWay2_SW;
836	priv->dot11_current_preamble_mode = PREAMBLE_AUTO;	833	priv->dot11_current_preamble_mode = PREAMBLE_AUTO;
837	priv->rtllib->status = 0;	834	priv->rtllib->status = 0;
838	priv->polling_timer_on = 0;	835	priv->polling_timer_on = 0;
839	priv->up_first_time = 1;	836	priv->up_first_time = 1;
840	priv->blinked_ingpio = false;	837	priv->blinked_ingpio = false;
841	priv->bDriverIsGoingToUnload = false;
842	priv->being_init_adapter = false;	838	priv->being_init_adapter = false;
843	priv->initialized_at_probe = false;
844	priv->bdisable_nic = false;	839	priv->bdisable_nic = false;
845	priv->bfirst_init = false;	840	priv->bfirst_init = false;
846	priv->txringcount = 64;	841	priv->txringcount = 64;
@@ -848,12 +843,12 @@ static void _rtl92e_init_priv_variable(struct net_device *dev) · 1 unmodified line
848	priv->rxringcount = MAX_RX_COUNT;	843	priv->rxringcount = MAX_RX_COUNT;
849	priv->irq_enabled = 0;	844	priv->irq_enabled = 0;
850	priv->chan = 1;	845	priv->chan = 1;
851	priv->RegChannelPlan = 0xf;	846	priv->reg_chnl_plan = 0xf;
852	priv->rtllib->mode = WIRELESS_MODE_AUTO;	847	priv->rtllib->mode = WIRELESS_MODE_AUTO;
853	priv->rtllib->iw_mode = IW_MODE_INFRA;	848	priv->rtllib->iw_mode = IW_MODE_INFRA;
854	priv->rtllib->bNetPromiscuousMode = false;	849	priv->rtllib->net_promiscuous_md = false;
855	priv->rtllib->IntelPromiscuousModeInfo.bPromiscuousOn = false;	850	priv->rtllib->intel_promiscuous_md_info.promiscuous_on = false;
856	priv->rtllib->IntelPromiscuousModeInfo.bFilterSourceStationFrame =	851	priv->rtllib->intel_promiscuous_md_info.fltr_src_sta_frame =
857	false;	852	false;
858	priv->rtllib->ieee_up = 0;	853	priv->rtllib->ieee_up = 0;
859	priv->retry_rts = DEFAULT_RETRY_RTS;	854	priv->retry_rts = DEFAULT_RETRY_RTS;
@@ -864,32 +859,21 @@ static void _rtl92e_init_priv_variable(struct net_device *dev) · 4 unmodified lines
864	priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;	859	priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
865	priv->bcck_in_ch14 = false;	860	priv->bcck_in_ch14 = false;
866	priv->bfsync_processing = false;	861	priv->bfsync_processing = false;
867	priv->CCKPresentAttentuation = 0;	862	priv->cck_present_attn = 0;
868	priv->rfa_txpowertrackingindex = 0;	863	priv->rfa_txpowertrackingindex = 0;
869	priv->rfc_txpowertrackingindex = 0;	864	priv->rfc_txpowertrackingindex = 0;
870	priv->CckPwEnl = 6;	865	priv->CckPwEnl = 6;
871	priv->ScanDelay = 50;	866	priv->rst_progress = RESET_TYPE_NORESET;
872	priv->ResetProgress = RESET_TYPE_NORESET;
873	priv->bForcedSilentReset = false;
874	priv->bDisableNormalResetCheck = false;
875	priv->force_reset = false;	867	priv->force_reset = false;
876	memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32);	868	memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32);
877		869	priv->rx_ctr = 0;
878	memset(&priv->InterruptLog, 0, sizeof(struct log_int_8190));
879	priv->RxCounter = 0;
880	priv->rtllib->wx_set_enc = 0;	870	priv->rtllib->wx_set_enc = 0;
881	priv->hw_radio_off = false;	871	priv->hw_radio_off = false;
882	priv->RegRfOff = false;
883	priv->isRFOff = false;
884	priv->bInPowerSaveMode = false;
885	priv->rtllib->rf_off_reason = 0;	872	priv->rtllib->rf_off_reason = 0;
886	priv->rf_change_in_progress = false;	873	priv->rf_change_in_progress = false;
887	priv->bHwRfOffAction = 0;	874	priv->hw_rf_off_action = 0;
888	priv->SetRFPowerStateInProgress = false;	875	priv->SetRFPowerStateInProgress = false;
889	priv->rtllib->PowerSaveControl.bInactivePs = true;	876	priv->rtllib->pwr_save_ctrl.bLeisurePs = true;
890	priv->rtllib->PowerSaveControl.bIPSModeBackup = false;
891	priv->rtllib->PowerSaveControl.bLeisurePs = true;
892	priv->rtllib->PowerSaveControl.bFwCtrlLPS = false;
893	priv->rtllib->LPSDelayCnt = 0;	877	priv->rtllib->LPSDelayCnt = 0;
894	priv->rtllib->sta_sleep = LPS_IS_WAKE;	878	priv->rtllib->sta_sleep = LPS_IS_WAKE;
895	priv->rtllib->rf_power_state = rf_on;	879	priv->rtllib->rf_power_state = rf_on;
@@ -916,8 +900,6 @@ static void _rtl92e_init_priv_variable(struct net_device *dev) · 20 unmodified lines
916		900
917	for (i = 0; i < MAX_QUEUE_SIZE; i++)	901	for (i = 0; i < MAX_QUEUE_SIZE; i++)
918	skb_queue_head_init(&priv->rtllib->skb_waitQ[i]);	902	skb_queue_head_init(&priv->rtllib->skb_waitQ[i]);
919	for (i = 0; i < MAX_QUEUE_SIZE; i++)
920	skb_queue_head_init(&priv->rtllib->skb_aggQ[i]);
921	}	903	}
922		904
923	static void _rtl92e_init_priv_lock(struct r8192_priv *priv)	905	static void _rtl92e_init_priv_lock(struct r8192_priv *priv)
@@ -1147,8 +1129,8 @@ static void _rtl92e_if_silent_reset(struct net_device *dev) · 223 unmodified lines
1147	struct rtllib_device *ieee = priv->rtllib;	1129	struct rtllib_device *ieee = priv->rtllib;
1148	unsigned long flag;	1130	unsigned long flag;
1149		1131
1150	if (priv->ResetProgress == RESET_TYPE_NORESET) {	1132	if (priv->rst_progress == RESET_TYPE_NORESET) {
1151	priv->ResetProgress = RESET_TYPE_SILENT;	1133	priv->rst_progress = RESET_TYPE_SILENT;
1152		1134
1153	spin_lock_irqsave(&priv->rf_ps_lock, flag);	1135	spin_lock_irqsave(&priv->rf_ps_lock, flag);
1154	if (priv->rf_change_in_progress) {	1136	if (priv->rf_change_in_progress) {
@@ -1245,10 +1227,8 @@ RESET_START: · 90 unmodified lines
1245	rtl92e_cam_restore(dev);	1227	rtl92e_cam_restore(dev);
1246	rtl92e_dm_restore_state(dev);	1228	rtl92e_dm_restore_state(dev);
1247	END:	1229	END:
1248	priv->ResetProgress = RESET_TYPE_NORESET;	1230	priv->rst_progress = RESET_TYPE_NORESET;
1249	priv->reset_count++;	1231	priv->reset_count++;
1250
1251	priv->bForcedSilentReset = false;
1252	priv->bResetInProgress = false;	1232	priv->bResetInProgress = false;
1253		1233
1254	rtl92e_writeb(dev, UFWP, 1);	1234	rtl92e_writeb(dev, UFWP, 1);
@@ -1264,15 +1244,15 @@ static void _rtl92e_update_rxcounts(struct r8192_priv priv, u32 TotalRxBcnNum, · 9 unmodified lines
1264	*TotalRxBcnNum = 0;	1244	*TotalRxBcnNum = 0;
1265	*TotalRxDataNum = 0;	1245	*TotalRxDataNum = 0;
1266		1246
1267	SlotIndex = (priv->rtllib->LinkDetectInfo.SlotIndex++) %	1247	SlotIndex = (priv->rtllib->link_detect_info.SlotIndex++) %
1268	(priv->rtllib->LinkDetectInfo.SlotNum);	1248	(priv->rtllib->link_detect_info.SlotNum);
1269	priv->rtllib->LinkDetectInfo.RxBcnNum[SlotIndex] =	1249	priv->rtllib->link_detect_info.RxBcnNum[SlotIndex] =
1270	priv->rtllib->LinkDetectInfo.NumRecvBcnInPeriod;	1250	priv->rtllib->link_detect_info.NumRecvBcnInPeriod;
1271	priv->rtllib->LinkDetectInfo.RxDataNum[SlotIndex] =	1251	priv->rtllib->link_detect_info.RxDataNum[SlotIndex] =
1272	priv->rtllib->LinkDetectInfo.NumRecvDataInPeriod;	1252	priv->rtllib->link_detect_info.NumRecvDataInPeriod;
1273	for (i = 0; i < priv->rtllib->LinkDetectInfo.SlotNum; i++) {	1253	for (i = 0; i < priv->rtllib->link_detect_info.SlotNum; i++) {
1274	*TotalRxBcnNum += priv->rtllib->LinkDetectInfo.RxBcnNum[i];	1254	*TotalRxBcnNum += priv->rtllib->link_detect_info.RxBcnNum[i];
1275	*TotalRxDataNum += priv->rtllib->LinkDetectInfo.RxDataNum[i];	1255	*TotalRxDataNum += priv->rtllib->link_detect_info.RxDataNum[i];
1276	}	1256	}
1277	}	1257	}
1278		1258
@@ -1285,8 +1265,8 @@ static void _rtl92e_watchdog_wq_cb(void *data) · 6 unmodified lines
1285	enum reset_type ResetType = RESET_TYPE_NORESET;	1265	enum reset_type ResetType = RESET_TYPE_NORESET;
1286	static u8 check_reset_cnt;	1266	static u8 check_reset_cnt;
1287	unsigned long flags;	1267	unsigned long flags;
1288	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )	1268	struct rt_pwr_save_ctrl psc = (struct rt_pwr_save_ctrl )
1289	(&priv->rtllib->PowerSaveControl);	1269	(&priv->rtllib->pwr_save_ctrl);
1290	bool bBusyTraffic = false;	1270	bool bBusyTraffic = false;
1291	bool bHigherBusyTraffic = false;	1271	bool bHigherBusyTraffic = false;
1292	bool bHigherBusyRxTraffic = false;	1272	bool bHigherBusyRxTraffic = false;
@@ -1309,31 +1289,31 @@ static void _rtl92e_watchdog_wq_cb(void *data) · 16 unmodified lines
1309	RTLLIB_NOLINK) &&	1289	RTLLIB_NOLINK) &&
1310	(ieee->rf_power_state == rf_on) && !ieee->is_set_key &&	1290	(ieee->rf_power_state == rf_on) && !ieee->is_set_key &&
1311	(!ieee->proto_stoppping) && !ieee->wx_set_enc) {	1291	(!ieee->proto_stoppping) && !ieee->wx_set_enc) {
1312	if ((ieee->PowerSaveControl.ReturnPoint ==	1292	if ((ieee->pwr_save_ctrl.ReturnPoint ==
1313	IPS_CALLBACK_NONE) &&	1293	IPS_CALLBACK_NONE) &&
1314	(!ieee->bNetPromiscuousMode)) {	1294	(!ieee->net_promiscuous_md)) {
1315	rtl92e_ips_enter(dev);	1295	rtl92e_ips_enter(dev);
1316	}	1296	}
1317	}	1297	}
1318	}	1298	}
1319	if ((ieee->state == RTLLIB_LINKED) && (ieee->iw_mode ==	1299	if ((ieee->state == RTLLIB_LINKED) && (ieee->iw_mode ==
1320	IW_MODE_INFRA) && (!ieee->bNetPromiscuousMode)) {	1300	IW_MODE_INFRA) && (!ieee->net_promiscuous_md)) {
1321	if (ieee->LinkDetectInfo.NumRxOkInPeriod > 100 \|\|	1301	if (ieee->link_detect_info.NumRxOkInPeriod > 100 \|\|
1322	ieee->LinkDetectInfo.NumTxOkInPeriod > 100)	1302	ieee->link_detect_info.NumTxOkInPeriod > 100)
1323	bBusyTraffic = true;	1303	bBusyTraffic = true;
1324		1304
1325	if (ieee->LinkDetectInfo.NumRxOkInPeriod > 4000 \|\|	1305	if (ieee->link_detect_info.NumRxOkInPeriod > 4000 \|\|
1326	ieee->LinkDetectInfo.NumTxOkInPeriod > 4000) {	1306	ieee->link_detect_info.NumTxOkInPeriod > 4000) {
1327	bHigherBusyTraffic = true;	1307	bHigherBusyTraffic = true;
1328	if (ieee->LinkDetectInfo.NumRxOkInPeriod > 5000)	1308	if (ieee->link_detect_info.NumRxOkInPeriod > 5000)
1329	bHigherBusyRxTraffic = true;	1309	bHigherBusyRxTraffic = true;
1330	else	1310	else
1331	bHigherBusyRxTraffic = false;	1311	bHigherBusyRxTraffic = false;
1332	}	1312	}
1333		1313
1334	if (((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod +	1314	if (((ieee->link_detect_info.NumRxUnicastOkInPeriod +
1335	ieee->LinkDetectInfo.NumTxOkInPeriod) > 8) \|\|	1315	ieee->link_detect_info.NumTxOkInPeriod) > 8) \|\|
1336	(ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2))	1316	(ieee->link_detect_info.NumRxUnicastOkInPeriod > 2))
1337	bEnterPS = false;	1317	bEnterPS = false;
1338	else	1318	else
1339	bEnterPS = true;	1319	bEnterPS = true;
@@ -1350,13 +1330,13 @@ static void _rtl92e_watchdog_wq_cb(void *data) · 10 unmodified lines
1350	rtl92e_leisure_ps_leave(dev);	1330	rtl92e_leisure_ps_leave(dev);
1351	}	1331	}
1352		1332
1353	ieee->LinkDetectInfo.NumRxOkInPeriod = 0;	1333	ieee->link_detect_info.NumRxOkInPeriod = 0;
1354	ieee->LinkDetectInfo.NumTxOkInPeriod = 0;	1334	ieee->link_detect_info.NumTxOkInPeriod = 0;
1355	ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;	1335	ieee->link_detect_info.NumRxUnicastOkInPeriod = 0;
1356	ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;	1336	ieee->link_detect_info.bBusyTraffic = bBusyTraffic;
1357		1337
1358	ieee->LinkDetectInfo.bHigherBusyTraffic = bHigherBusyTraffic;	1338	ieee->link_detect_info.bHigherBusyTraffic = bHigherBusyTraffic;
1359	ieee->LinkDetectInfo.bHigherBusyRxTraffic = bHigherBusyRxTraffic;	1339	ieee->link_detect_info.bHigherBusyRxTraffic = bHigherBusyRxTraffic;
1360		1340
1361	if (ieee->state == RTLLIB_LINKED && ieee->iw_mode == IW_MODE_INFRA) {	1341	if (ieee->state == RTLLIB_LINKED && ieee->iw_mode == IW_MODE_INFRA) {
1362	u32 TotalRxBcnNum = 0;	1342	u32 TotalRxBcnNum = 0;
@@ -1397,28 +1377,26 @@ static void _rtl92e_watchdog_wq_cb(void *data) · 34 unmodified lines
1397		1377
1398	priv->check_roaming_cnt = 0;	1378	priv->check_roaming_cnt = 0;
1399	}	1379	}
1400	ieee->LinkDetectInfo.NumRecvBcnInPeriod = 0;	1380	ieee->link_detect_info.NumRecvBcnInPeriod = 0;
1401	ieee->LinkDetectInfo.NumRecvDataInPeriod = 0;	1381	ieee->link_detect_info.NumRecvDataInPeriod = 0;
1402	}	1382	}
1403		1383
1404	spin_lock_irqsave(&priv->tx_lock, flags);	1384	spin_lock_irqsave(&priv->tx_lock, flags);
1405	if ((check_reset_cnt++ >= 3) && (!ieee->is_roaming) &&	1385	if ((check_reset_cnt++ >= 3) && (!ieee->is_roaming) &&
1406	(!priv->rf_change_in_progress) && (!pPSC->bSwRfProcessing)) {	1386	(!priv->rf_change_in_progress) && (!psc->bSwRfProcessing)) {
1407	ResetType = _rtl92e_if_check_reset(dev);	1387	ResetType = _rtl92e_if_check_reset(dev);
1408	check_reset_cnt = 3;	1388	check_reset_cnt = 3;
1409	}	1389	}
1410	spin_unlock_irqrestore(&priv->tx_lock, flags);	1390	spin_unlock_irqrestore(&priv->tx_lock, flags);
1411		1391
1412	if (!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_NORMAL) {	1392	if (ResetType == RESET_TYPE_NORMAL) {
1413	priv->ResetProgress = RESET_TYPE_NORMAL;	1393	priv->rst_progress = RESET_TYPE_NORMAL;
1414	return;	1394	return;
1415	}	1395	}
1416		1396
1417	if (((priv->force_reset) \|\| (!priv->bDisableNormalResetCheck &&	1397	if ((priv->force_reset \|\| ResetType == RESET_TYPE_SILENT))
1418	ResetType == RESET_TYPE_SILENT)))
1419	_rtl92e_if_silent_reset(dev);	1398	_rtl92e_if_silent_reset(dev);
1420	priv->force_reset = false;	1399	priv->force_reset = false;
1421	priv->bForcedSilentReset = false;
1422	priv->bResetInProgress = false;	1400	priv->bResetInProgress = false;
1423	}	1401	}
1424		1402
@@ -1554,8 +1532,8 @@ static int _rtl92e_hard_start_xmit(struct sk_buff skb, struct net_device dev) · 129 unmodified lines
1554	}	1532	}
1555		1533
1556	tcb_desc->RATRIndex = 7;	1534	tcb_desc->RATRIndex = 7;
1557	tcb_desc->bTxDisableRateFallBack = 1;	1535	tcb_desc->tx_dis_rate_fallback = 1;
1558	tcb_desc->bTxUseDriverAssingedRate = 1;	1536	tcb_desc->tx_use_drv_assinged_rate = 1;
1559	tcb_desc->bTxEnableFwCalcDur = 1;	1537	tcb_desc->bTxEnableFwCalcDur = 1;
1560	skb_push(skb, priv->rtllib->tx_headroom);	1538	skb_push(skb, priv->rtllib->tx_headroom);
1561	ret = _rtl92e_tx(dev, skb);	1539	ret = _rtl92e_tx(dev, skb);
@@ -2205,7 +2183,6 @@ static irqreturn_t _rtl92e_irq(int irq, void *netdev) · 643 unmodified lines
2205		2183
2206	if (inta & IMR_ROK) {	2184	if (inta & IMR_ROK) {
2207	priv->stats.rxint++;	2185	priv->stats.rxint++;
2208	priv->InterruptLog.nIMR_ROK++;
2209	tasklet_schedule(&priv->irq_rx_tasklet);	2186	tasklet_schedule(&priv->irq_rx_tasklet);
2210	}	2187	}
2211		2188
@@ -2229,25 +2206,25 @@ static irqreturn_t _rtl92e_irq(int irq, void *netdev) · 17 unmodified lines
2229		2206
2230	if (inta & IMR_BKDOK) {	2207	if (inta & IMR_BKDOK) {
2231	priv->stats.txbkokint++;	2208	priv->stats.txbkokint++;
2232	priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;	2209	priv->rtllib->link_detect_info.NumTxOkInPeriod++;
2233	_rtl92e_tx_isr(dev, BK_QUEUE);	2210	_rtl92e_tx_isr(dev, BK_QUEUE);
2234	}	2211	}
2235		2212
2236	if (inta & IMR_BEDOK) {	2213	if (inta & IMR_BEDOK) {
2237	priv->stats.txbeokint++;	2214	priv->stats.txbeokint++;
2238	priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;	2215	priv->rtllib->link_detect_info.NumTxOkInPeriod++;
2239	_rtl92e_tx_isr(dev, BE_QUEUE);	2216	_rtl92e_tx_isr(dev, BE_QUEUE);
2240	}	2217	}
2241		2218
2242	if (inta & IMR_VIDOK) {	2219	if (inta & IMR_VIDOK) {
2243	priv->stats.txviokint++;	2220	priv->stats.txviokint++;
2244	priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;	2221	priv->rtllib->link_detect_info.NumTxOkInPeriod++;
2245	_rtl92e_tx_isr(dev, VI_QUEUE);	2222	_rtl92e_tx_isr(dev, VI_QUEUE);
2246	}	2223	}
2247		2224
2248	if (inta & IMR_VODOK) {	2225	if (inta & IMR_VODOK) {
2249	priv->stats.txvookint++;	2226	priv->stats.txvookint++;
2250	priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;	2227	priv->rtllib->link_detect_info.NumTxOkInPeriod++;
2251	_rtl92e_tx_isr(dev, VO_QUEUE);	2228	_rtl92e_tx_isr(dev, VO_QUEUE);
2252	}	2229	}
2253		2230
@@ -2437,8 +2414,8 @@ bool rtl92e_enable_nic(struct net_device *dev) · 183 unmodified lines
2437	{	2414	{
2438	bool init_status = true;	2415	bool init_status = true;
2439	struct r8192_priv *priv = rtllib_priv(dev);	2416	struct r8192_priv *priv = rtllib_priv(dev);
2440	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )	2417	struct rt_pwr_save_ctrl psc = (struct rt_pwr_save_ctrl )
2441	(&priv->rtllib->PowerSaveControl);	2418	(&priv->rtllib->pwr_save_ctrl);
2442		2419
2443	if (!priv->up) {	2420	if (!priv->up) {
2444	netdev_warn(dev, "%s(): Driver is already down!\n", __func__);	2421	netdev_warn(dev, "%s(): Driver is already down!\n", __func__);
@@ -2453,7 +2430,7 @@ bool rtl92e_enable_nic(struct net_device *dev) · 8 unmodified lines
2453	priv->bdisable_nic = false;	2430	priv->bdisable_nic = false;
2454	return false;	2431	return false;
2455	}	2432	}
2456	RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);	2433	RT_CLEAR_PS_LEVEL(psc, RT_RF_OFF_LEVL_HALT_NIC);
2457	priv->bfirst_init = false;	2434	priv->bfirst_init = false;
2458		2435
2459	rtl92e_irq_enable(dev);	2436	rtl92e_irq_enable(dev);

drivers/staging/rtl8192e/rtl8192e/rtl_core.h+5−31

@@ -234,15 +234,6 @@ struct rt_stats { · 233 unmodified lines
234	u32 CurrentShowTxate;	234	u32 CurrentShowTxate;
235	};	235	};
236		236
237	struct channel_access_setting {
238	u16 SIFS_Timer;
239	u16 DIFS_Timer;
240	u16 SlotTimeTimer;
241	u16 EIFS_Timer;
242	u16 CWminIndex;
243	u16 CWmaxIndex;
244	};
245
246	struct init_gain {	237	struct init_gain {
247	u8 xaagccore1;	238	u8 xaagccore1;
248	u8 xbagccore1;	239	u8 xbagccore1;
@@ -309,9 +300,7 @@ struct r8192_priv { · 60 unmodified lines
309		300
310	bool bfirst_init;	301	bool bfirst_init;
311	bool bfirst_after_down;	302	bool bfirst_after_down;
312	bool initialized_at_probe;
313	bool being_init_adapter;	303	bool being_init_adapter;
314	bool bDriverIsGoingToUnload;
315		304
316	int irq;	305	int irq;
317	short irq_enabled;	306	short irq_enabled;
@@ -323,16 +312,11 @@ struct r8192_priv { · 5 unmodified lines
323	struct delayed_work txpower_tracking_wq;	312	struct delayed_work txpower_tracking_wq;
324	struct delayed_work rfpath_check_wq;	313	struct delayed_work rfpath_check_wq;
325	struct delayed_work gpio_change_rf_wq;	314	struct delayed_work gpio_change_rf_wq;
326
327	struct channel_access_setting ChannelAccessSetting;
328
329	struct rtl819x_ops *ops;	315	struct rtl819x_ops *ops;
330	struct rtllib_device *rtllib;	316	struct rtllib_device *rtllib;
331		317
332	struct work_struct reset_wq;	318	struct work_struct reset_wq;
333		319
334	struct log_int_8190 InterruptLog;
335
336	enum rt_customer_id CustomerID;	320	enum rt_customer_id CustomerID;
337		321
338		322
@@ -341,8 +325,6 @@ struct r8192_priv { · 2 unmodified lines
341	struct bb_reg_definition PHYRegDef[4];	325	struct bb_reg_definition PHYRegDef[4];
342	struct rate_adaptive rate_adaptive;	326	struct rate_adaptive rate_adaptive;
343		327
344	enum acm_method AcmMethod;
345
346	struct rt_firmware *pFirmware;	328	struct rt_firmware *pFirmware;
347	enum rtl819x_loopback LoopbackMode;	329	enum rtl819x_loopback LoopbackMode;
348		330
@@ -410,8 +392,6 @@ struct r8192_priv { · 61 unmodified lines
410	short chan;	392	short chan;
411	short sens;	393	short sens;
412	short max_sens;	394	short max_sens;
413
414	u8 ScanDelay;
415	bool ps_force;	395	bool ps_force;
416		396
417	u32 irq_mask[2];	397	u32 irq_mask[2];
@@ -470,13 +450,9 @@ struct r8192_priv { · 52 unmodified lines
470		450
471	bool bTXPowerDataReadFromEEPORM;	451	bool bTXPowerDataReadFromEEPORM;
472		452
473	u16 RegChannelPlan;	453	u16 reg_chnl_plan;
474	u16 ChannelPlan;	454	u16 ChannelPlan;
475		455	u8 hw_rf_off_action;
476	bool RegRfOff;
477	bool isRFOff;
478	bool bInPowerSaveMode;
479	u8 bHwRfOffAction;
480		456
481	bool rf_change_in_progress;	457	bool rf_change_in_progress;
482	bool SetRFPowerStateInProgress;	458	bool SetRFPowerStateInProgress;
@@ -490,7 +466,7 @@ struct r8192_priv { · 7 unmodified lines
490	u8 CCKPresentAttentuation_20Mdefault;	466	u8 CCKPresentAttentuation_20Mdefault;
491	u8 CCKPresentAttentuation_40Mdefault;	467	u8 CCKPresentAttentuation_40Mdefault;
492	s8 CCKPresentAttentuation_difference;	468	s8 CCKPresentAttentuation_difference;
493	s8 CCKPresentAttentuation;	469	s8 cck_present_attn;
494	long undecorated_smoothed_pwdb;	470	long undecorated_smoothed_pwdb;
495		471
496	u32 MCSTxPowerLevelOriginalOffset[6];	472	u32 MCSTxPowerLevelOriginalOffset[6];
@@ -543,11 +519,9 @@ struct r8192_priv { · 46 unmodified lines
543		519
544	u32 reset_count;	520	u32 reset_count;
545		521
546	enum reset_type ResetProgress;	522	enum reset_type rst_progress;
547	bool bForcedSilentReset;
548	bool bDisableNormalResetCheck;
549	u16 TxCounter;	523	u16 TxCounter;
550	u16 RxCounter;	524	u16 rx_ctr;
551	bool bResetInProgress;	525	bool bResetInProgress;
552	bool force_reset;	526	bool force_reset;
553	bool force_lps;	527	bool force_lps;

drivers/staging/rtl8192e/rtl8192e/rtl_dm.c+59−64

 			"PATH=/usr/bin:/bin",
 			 NULL};
-	if (priv->ResetProgress == RESET_TYPE_SILENT) {
+	if (priv->rst_progress == RESET_TYPE_SILENT)
 		return;
-	}
 	if (priv->rtllib->state != RTLLIB_LINKED)
 		return;
 	call_usermodehelper(ac_dc_script, argv, envp, UMH_WAIT_PROC);
 static void _rtl92e_dm_check_rate_adaptive(struct net_device *dev)
 {
 	struct r8192_priv *priv = rtllib_priv(dev);
-	struct rt_hi_throughput *pHTInfo = priv->rtllib->pHTInfo;
+	struct rt_hi_throughput *ht_info = priv->rtllib->ht_info;
 	struct rate_adaptive *pra = &priv->rate_adaptive;
 	u32 currentRATR, targetRATR = 0;
 	u32 LowRSSIThreshForRA = 0, HighRSSIThreshForRA = 0;
 	bool bshort_gi_enabled = false;
 	static u8 ping_rssi_state;
-	if (!priv->up) {
+	if (!priv->up)
 		return;
-	}
 	if (pra->rate_adaptive_disabled)
 		return;
 	if (priv->rtllib->state == RTLLIB_LINKED) {
-		bshort_gi_enabled = (pHTInfo->cur_tx_bw40mhz &&
+		bshort_gi_enabled = (ht_info->cur_tx_bw40mhz &&
-				     pHTInfo->bCurShortGI40MHz) ||
+				     ht_info->bCurShortGI40MHz) ||
-				    (!pHTInfo->cur_tx_bw40mhz &&
+				    (!ht_info->cur_tx_bw40mhz &&
-				     pHTInfo->bCurShortGI20MHz);
+				     ht_info->bCurShortGI20MHz);
 		pra->upper_rssi_threshold_ratr =
 				(pra->upper_rssi_threshold_ratr & (~BIT31)) |
 	for (j = 0; j <= 30; j++) {
-		tx_cmd.Op		= TXCMD_SET_TX_PWR_TRACKING;
+		tx_cmd.op	= TXCMD_SET_TX_PWR_TRACKING;
-		tx_cmd.Length	= 4;
+		tx_cmd.length	= 4;
-		tx_cmd.Value		= Value;
+		tx_cmd.value	= Value;
 		rtl92e_send_cmd_pkt(dev, DESC_PACKET_TYPE_NORMAL, (u8 *)&tx_cmd,
 				    sizeof(struct dcmd_txcmd));
 		mdelay(1);
 			}
 			if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20)
-				priv->CCKPresentAttentuation =
+				priv->cck_present_attn =
 					 priv->CCKPresentAttentuation_20Mdefault +
 					 priv->CCKPresentAttentuation_difference;
 			else
-				priv->CCKPresentAttentuation =
+				priv->cck_present_attn =
 					 priv->CCKPresentAttentuation_40Mdefault +
 					 priv->CCKPresentAttentuation_difference;
-			if (priv->CCKPresentAttentuation > (CCKTxBBGainTableLength-1))
+			if (priv->cck_present_attn > (CCKTxBBGainTableLength-1))
-				priv->CCKPresentAttentuation = CCKTxBBGainTableLength-1;
+				priv->cck_present_attn = CCKTxBBGainTableLength-1;
-			if (priv->CCKPresentAttentuation < 0)
+			if (priv->cck_present_attn < 0)
-				priv->CCKPresentAttentuation = 0;
+				priv->cck_present_attn = 0;
-			if (priv->CCKPresentAttentuation > -1 &&
+			if (priv->cck_present_attn > -1 &&
-			    priv->CCKPresentAttentuation < CCKTxBBGainTableLength) {
+			    priv->cck_present_attn < CCKTxBBGainTableLength) {
 				if (priv->rtllib->current_network.channel == 14 &&
 				    !priv->bcck_in_ch14) {
 					priv->bcck_in_ch14 = true;
 		tmpRegA = rtl92e_get_bb_reg(dev, rOFDM0_XATxIQImbalance,
 					    bMaskDWord);
 		for (i = 0; i < OFDM_Table_Length; i++) {
-			if (tmpRegA == OFDMSwingTable[i]) {
+			if (tmpRegA == OFDMSwingTable[i])
 				priv->OFDM_index[0] = i;
-			}
 		}
 		TempCCk = rtl92e_get_bb_reg(dev, rCCK0_TxFilter1, bMaskByte2);
 {
 	u32 TempVal;
 	struct r8192_priv *priv = rtllib_priv(dev);
-	u8 attenuation = priv->CCKPresentAttentuation;
+	u8 attenuation = priv->cck_present_attn;
 	TempVal = 0;
 	if (!bInCH14) {
 	u32	reg_ratr = priv->rate_adaptive.last_ratr;
 	u32 ratr_value;
-	if (!priv->up) {
+	if (!priv->up)
 		return;
-	}
 	if (priv->rate_adaptive.rate_adaptive_disabled)
 		return;
 	dm_digtable.dig_state		= DM_STA_DIG_MAX;
 	dm_digtable.dig_highpwr_state	= DM_STA_DIG_MAX;
-	dm_digtable.CurSTAConnectState = DIG_STA_DISCONNECT;
+	dm_digtable.cur_sta_connect_state = DIG_STA_DISCONNECT;
-	dm_digtable.PreSTAConnectState = DIG_STA_DISCONNECT;
+	dm_digtable.pre_sta_connect_state = DIG_STA_DISCONNECT;
 	dm_digtable.rssi_low_thresh	= DM_DIG_THRESH_LOW;
 	dm_digtable.rssi_high_thresh	= DM_DIG_THRESH_HIGH;
 	}
 	if (priv->rtllib->state == RTLLIB_LINKED)
-		dm_digtable.CurSTAConnectState = DIG_STA_CONNECT;
+		dm_digtable.cur_sta_connect_state = DIG_STA_CONNECT;
 	else
-		dm_digtable.CurSTAConnectState = DIG_STA_DISCONNECT;
+		dm_digtable.cur_sta_connect_state = DIG_STA_DISCONNECT;
 	dm_digtable.rssi_val = priv->undecorated_smoothed_pwdb;
 	_rtl92e_dm_cs_ratio(dev);
 	if (dm_digtable.dig_algorithm_switch)
 		dm_digtable.dig_algorithm_switch = 0;
-	dm_digtable.PreSTAConnectState = dm_digtable.CurSTAConnectState;
+	dm_digtable.pre_sta_connect_state = dm_digtable.cur_sta_connect_state;
 }
 		return;
 	}
-	if (dm_digtable.PreSTAConnectState == dm_digtable.CurSTAConnectState) {
+	if (dm_digtable.pre_sta_connect_state == dm_digtable.cur_sta_connect_state) {
-		if (dm_digtable.CurSTAConnectState == DIG_STA_CONNECT) {
+		if (dm_digtable.cur_sta_connect_state == DIG_STA_CONNECT) {
 			long gain_range = dm_digtable.rssi_val + 10 -
 					  dm_digtable.backoff_val;
 			gain_range = clamp_t(long, gain_range,
 		reset_cnt = 0;
 	}
-	if (dm_digtable.PreSTAConnectState == dm_digtable.CurSTAConnectState) {
+	if (dm_digtable.pre_sta_connect_state == dm_digtable.cur_sta_connect_state) {
-		if (dm_digtable.CurSTAConnectState == DIG_STA_CONNECT) {
+		if (dm_digtable.cur_sta_connect_state == DIG_STA_CONNECT) {
 			if (dm_digtable.rssi_val >=
 			    dm_digtable.rssi_high_power_highthresh)
 				dm_digtable.curpd_thstate =
 		reset_cnt = 0;
 	}
-	if (dm_digtable.PreSTAConnectState == dm_digtable.CurSTAConnectState) {
+	if (dm_digtable.pre_sta_connect_state == dm_digtable.cur_sta_connect_state) {
-		if (dm_digtable.CurSTAConnectState == DIG_STA_CONNECT) {
+		if (dm_digtable.cur_sta_connect_state == DIG_STA_CONNECT) {
 			if (dm_digtable.rssi_val <= dm_digtable.rssi_low_thresh)
 				dm_digtable.curcs_ratio_state = DIG_CS_RATIO_LOWER;
 			else if (dm_digtable.rssi_val >= dm_digtable.rssi_high_thresh)
 static void _rtl92e_dm_check_edca_turbo(struct net_device *dev)
 {
 	struct r8192_priv *priv = rtllib_priv(dev);
-	struct rt_hi_throughput *pHTInfo = priv->rtllib->pHTInfo;
+	struct rt_hi_throughput *ht_info = priv->rtllib->ht_info;
 	static unsigned long lastTxOkCnt;
 	static unsigned long lastRxOkCnt;
 		goto dm_CheckEdcaTurbo_EXIT;
 	if (priv->rtllib->state != RTLLIB_LINKED)
 		goto dm_CheckEdcaTurbo_EXIT;
-	if (priv->rtllib->pHTInfo->iot_action & HT_IOT_ACT_DISABLE_EDCA_TURBO)
+	if (priv->rtllib->ht_info->iot_action & HT_IOT_ACT_DISABLE_EDCA_TURBO)
 		goto dm_CheckEdcaTurbo_EXIT;
 	if (!priv->rtllib->bis_any_nonbepkts) {
 		curTxOkCnt = priv->stats.txbytesunicast - lastTxOkCnt;
 		curRxOkCnt = priv->stats.rxbytesunicast - lastRxOkCnt;
-		if (pHTInfo->iot_action & HT_IOT_ACT_EDCA_BIAS_ON_RX) {
+		if (ht_info->iot_action & HT_IOT_ACT_EDCA_BIAS_ON_RX) {
 			if (curTxOkCnt > 4*curRxOkCnt) {
 				if (priv->bis_cur_rdlstate ||
 				    !priv->bcurrent_turbo_EDCA) {
 					rtl92e_writel(dev, EDCAPARA_BE,
-						      edca_setting_UL[pHTInfo->IOTPeer]);
+						      edca_setting_UL[ht_info->IOTPeer]);
 					priv->bis_cur_rdlstate = false;
 				}
 			} else {
 				    !priv->bcurrent_turbo_EDCA) {
 					if (priv->rtllib->mode == WIRELESS_MODE_G)
 						rtl92e_writel(dev, EDCAPARA_BE,
-							      edca_setting_DL_GMode[pHTInfo->IOTPeer]);
+							      edca_setting_DL_GMode[ht_info->IOTPeer]);
 					else
 						rtl92e_writel(dev, EDCAPARA_BE,
-							      edca_setting_DL[pHTInfo->IOTPeer]);
+							      edca_setting_DL[ht_info->IOTPeer]);
 					priv->bis_cur_rdlstate = true;
 				}
 			}
 				    !priv->bcurrent_turbo_EDCA) {
 					if (priv->rtllib->mode == WIRELESS_MODE_G)
 						rtl92e_writel(dev, EDCAPARA_BE,
-							      edca_setting_DL_GMode[pHTInfo->IOTPeer]);
+							      edca_setting_DL_GMode[ht_info->IOTPeer]);
 					else
 						rtl92e_writel(dev, EDCAPARA_BE,
-							      edca_setting_DL[pHTInfo->IOTPeer]);
+							      edca_setting_DL[ht_info->IOTPeer]);
 					priv->bis_cur_rdlstate = true;
 				}
 			} else {
 				if (priv->bis_cur_rdlstate ||
 				    !priv->bcurrent_turbo_EDCA) {
 					rtl92e_writel(dev, EDCAPARA_BE,
-						      edca_setting_UL[pHTInfo->IOTPeer]);
+						      edca_setting_UL[ht_info->IOTPeer]);
 					priv->bis_cur_rdlstate = false;
 				}
 static void _rtl92e_dm_cts_to_self(struct net_device *dev)
 {
 	struct r8192_priv *priv = rtllib_priv((struct net_device *)dev);
-	struct rt_hi_throughput *pHTInfo = priv->rtllib->pHTInfo;
+	struct rt_hi_throughput *ht_info = priv->rtllib->ht_info;
 	static unsigned long lastTxOkCnt;
 	static unsigned long lastRxOkCnt;
 	unsigned long curTxOkCnt = 0;
 	unsigned long curRxOkCnt = 0;
 	if (!priv->rtllib->bCTSToSelfEnable) {
-		pHTInfo->iot_action &= ~HT_IOT_ACT_FORCED_CTS2SELF;
+		ht_info->iot_action &= ~HT_IOT_ACT_FORCED_CTS2SELF;
 		return;
 	}
-	if (pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM) {
+	if (ht_info->IOTPeer == HT_IOT_PEER_BROADCOM) {
 		curTxOkCnt = priv->stats.txbytesunicast - lastTxOkCnt;
 		curRxOkCnt = priv->stats.rxbytesunicast - lastRxOkCnt;
 		if (curRxOkCnt > 4*curTxOkCnt)
-			pHTInfo->iot_action &= ~HT_IOT_ACT_FORCED_CTS2SELF;
+			ht_info->iot_action &= ~HT_IOT_ACT_FORCED_CTS2SELF;
 		else
-			pHTInfo->iot_action |= HT_IOT_ACT_FORCED_CTS2SELF;
+			ht_info->iot_action |= HT_IOT_ACT_FORCED_CTS2SELF;
 		lastTxOkCnt = priv->stats.txbytesunicast;
 		lastRxOkCnt = priv->stats.rxbytesunicast;
 static void _rtl92e_dm_init_wa_broadcom_iot(struct net_device *dev)
 {
 	struct r8192_priv *priv = rtllib_priv((struct net_device *)dev);
-	struct rt_hi_throughput *pHTInfo = priv->rtllib->pHTInfo;
+	struct rt_hi_throughput *ht_info = priv->rtllib->ht_info;
-	pHTInfo->bWAIotBroadcom = false;
+	ht_info->bWAIotBroadcom = false;
-	pHTInfo->WAIotTH = WAIotTHVal;
+	ht_info->WAIotTH = WAIotTHVal;
 }
 static void _rtl92e_dm_check_rf_ctrl_gpio(void *data)
 	if (bActuallySet) {
 		mdelay(1000);
-		priv->bHwRfOffAction = 1;
+		priv->hw_rf_off_action = 1;
 		rtl92e_set_rf_state(dev, rf_power_state_to_set, RF_CHANGE_BY_HW);
 		if (priv->hw_radio_off)
 			argv[1] = "RFOFF";
 	if (priv->rtllib->state == RTLLIB_LINKED &&
 	    priv->rtllib->bfsync_enable &&
-	    (priv->rtllib->pHTInfo->iot_action & HT_IOT_ACT_CDD_FSYNC)) {
+	    (priv->rtllib->ht_info->iot_action & HT_IOT_ACT_CDD_FSYNC)) {
 		u32 rate_bitmap;
 		for (rate_index = 0; rate_index <= 27; rate_index++) {
 static void _rtl92e_dm_start_sw_fsync(struct net_device *dev)
 {
 	struct r8192_priv *priv = rtllib_priv(dev);
-	u32			rateIndex;
+	u32 rate_index;
-	u32			rateBitmap;
+	u32 rate_bitmap;
 	priv->rate_record = 0;
 	priv->ContinueDiffCount = 0;
 		priv->rtllib->fsync_firstdiff_ratethreshold = 200;
 		priv->rtllib->fsync_seconddiff_ratethreshold = 200;
 	}
-	for (rateIndex = 0; rateIndex <= 27; rateIndex++) {
+	for (rate_index = 0; rate_index <= 27; rate_index++) {
-		rateBitmap  = 1 << rateIndex;
+		rate_bitmap  = 1 << rate_index;
-		if (priv->rtllib->fsync_rate_bitmap & rateBitmap)
+		if (priv->rtllib->fsync_rate_bitmap & rate_bitmap)
 			priv->rate_record +=
 				 priv->stats.received_rate_histogram[1]
-				[rateIndex];
+				[rate_index];
 	}
 	if (timer_pending(&priv->fsync_timer))
 		del_timer_sync(&priv->fsync_timer);
 	static u32 reset_cnt;
 	if (priv->rtllib->state == RTLLIB_LINKED &&
-	    priv->rtllib->pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM) {
+	    priv->rtllib->ht_info->IOTPeer == HT_IOT_PEER_BROADCOM) {
 		if (priv->rtllib->bfsync_enable == 0) {
 			switch (priv->rtllib->fsync_state) {
 			case Default_Fsync:
 		priv->bDynamicTxLowPower = false;
 		return;
 	}
-	if ((priv->rtllib->pHTInfo->IOTPeer == HT_IOT_PEER_ATHEROS) &&
+	if ((priv->rtllib->ht_info->IOTPeer == HT_IOT_PEER_ATHEROS) &&
 	    (priv->rtllib->mode == IEEE_G)) {
 		txhipower_threshold = TX_POWER_ATHEROAP_THRESH_HIGH;
 		txlowpower_threshold = TX_POWER_ATHEROAP_THRESH_LOW;

drivers/staging/rtl8192e/rtl8192e/rtl_dm.h+5−5

@@ -66,8 +66,8 @@ struct dig_t { · 65 unmodified lines
66		66
67	u8 dig_state;	67	u8 dig_state;
68	u8 dig_highpwr_state;	68	u8 dig_highpwr_state;
69	u8 CurSTAConnectState;	69	u8 cur_sta_connect_state;
70	u8 PreSTAConnectState;	70	u8 pre_sta_connect_state;
71		71
72	u8 curpd_thstate;	72	u8 curpd_thstate;
73	u8 prepd_thstate;	73	u8 prepd_thstate;
@@ -152,9 +152,9 @@ enum dm_cck_rx_path_method { · 78 unmodified lines
152		152
153		153
154	struct dcmd_txcmd {	154	struct dcmd_txcmd {
155	u32 Op;	155	u32 op;
156	u32 Length;	156	u32 length;
157	u32 Value;	157	u32 value;
158	};	158	};
159	/------------------------------Define structure----------------------------/	159	/------------------------------Define structure----------------------------/
160		160

drivers/staging/rtl8192e/rtl8192e/rtl_eeprom.c+1−1

@@ -79,6 +79,6 @@ u32 rtl92e_eeprom_read(struct net_device *dev, u32 addr) · 78 unmodified lines
79	ret = _rtl92e_eeprom_xfer(dev, (addr & 0x3F) \| (0x6 << 6), 9);	79	ret = _rtl92e_eeprom_xfer(dev, (addr & 0x3F) \| (0x6 << 6), 9);
80		80
81	rtl92e_writeb(dev, EPROM_CMD,	81	rtl92e_writeb(dev, EPROM_CMD,
82	(EPROM_CMD_NORMAL<<EPROM_CMD_OPERATING_MODE_SHIFT));	82	(EPROM_CMD_NORMAL << EPROM_CMD_OPERATING_MODE_SHIFT));
83	return ret;	83	return ret;
84	}	84	}

drivers/staging/rtl8192e/rtl8192e/rtl_ps.c+39−56

@@ -100,50 +100,43 @@ void rtl92e_enter_sleep(struct net_device *dev, u64 time) · 99 unmodified lines
100	static void _rtl92e_ps_update_rf_state(struct net_device *dev)	100	static void _rtl92e_ps_update_rf_state(struct net_device *dev)
101	{	101	{
102	struct r8192_priv *priv = rtllib_priv(dev);	102	struct r8192_priv *priv = rtllib_priv(dev);
103	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )	103	struct rt_pwr_save_ctrl psc = (struct rt_pwr_save_ctrl )
104	&(priv->rtllib->PowerSaveControl);	104	&priv->rtllib->pwr_save_ctrl;
105		105
106	pPSC->bSwRfProcessing = true;	106	psc->bSwRfProcessing = true;
107	rtl92e_set_rf_state(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);	107	rtl92e_set_rf_state(dev, psc->eInactivePowerState, RF_CHANGE_BY_IPS);
108		108
109	pPSC->bSwRfProcessing = false;	109	psc->bSwRfProcessing = false;
110	}	110	}
111		111
112	void rtl92e_ips_enter(struct net_device *dev)	112	void rtl92e_ips_enter(struct net_device *dev)
113	{	113	{
114	struct r8192_priv *priv = rtllib_priv(dev);	114	struct r8192_priv *priv = rtllib_priv(dev);
115	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )	115	struct rt_pwr_save_ctrl psc = (struct rt_pwr_save_ctrl )
116	&(priv->rtllib->PowerSaveControl);	116	&priv->rtllib->pwr_save_ctrl;
117	enum rt_rf_power_state rt_state;	117	enum rt_rf_power_state rt_state;
118		118
119	if (pPSC->bInactivePs) {	119	rt_state = priv->rtllib->rf_power_state;
120	rt_state = priv->rtllib->rf_power_state;	120	if (rt_state == rf_on && !psc->bSwRfProcessing &&
121	if (rt_state == rf_on && !pPSC->bSwRfProcessing &&	121	(priv->rtllib->state != RTLLIB_LINKED) &&
122	(priv->rtllib->state != RTLLIB_LINKED) &&	122	(priv->rtllib->iw_mode != IW_MODE_MASTER)) {
123	(priv->rtllib->iw_mode != IW_MODE_MASTER)) {	123	psc->eInactivePowerState = rf_off;
124	pPSC->eInactivePowerState = rf_off;	124	_rtl92e_ps_update_rf_state(dev);
125	priv->isRFOff = true;
126	priv->bInPowerSaveMode = true;
127	_rtl92e_ps_update_rf_state(dev);
128	}
129	}	125	}
130	}	126	}
131		127
132	void rtl92e_ips_leave(struct net_device *dev)	128	void rtl92e_ips_leave(struct net_device *dev)
133	{	129	{
134	struct r8192_priv *priv = rtllib_priv(dev);	130	struct r8192_priv *priv = rtllib_priv(dev);
135	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )	131	struct rt_pwr_save_ctrl psc = (struct rt_pwr_save_ctrl )
136	&(priv->rtllib->PowerSaveControl);	132	&priv->rtllib->pwr_save_ctrl;
137	enum rt_rf_power_state rt_state;	133	enum rt_rf_power_state rt_state;
138		134
139	if (pPSC->bInactivePs) {	135	rt_state = priv->rtllib->rf_power_state;
140	rt_state = priv->rtllib->rf_power_state;	136	if (rt_state != rf_on && !psc->bSwRfProcessing &&
141	if (rt_state != rf_on && !pPSC->bSwRfProcessing &&	137	priv->rtllib->rf_off_reason <= RF_CHANGE_BY_IPS) {
142	priv->rtllib->rf_off_reason <= RF_CHANGE_BY_IPS) {	138	psc->eInactivePowerState = rf_on;
143	pPSC->eInactivePowerState = rf_on;	139	_rtl92e_ps_update_rf_state(dev);
144	priv->bInPowerSaveMode = false;
145	_rtl92e_ps_update_rf_state(dev);
146	}
147	}	140	}
148	}	141	}
149		142
@@ -165,18 +158,15 @@ void rtl92e_rtllib_ips_leave_wq(struct net_device *dev) · 15 unmodified lines
165	enum rt_rf_power_state rt_state;	158	enum rt_rf_power_state rt_state;
166		159
167	rt_state = priv->rtllib->rf_power_state;	160	rt_state = priv->rtllib->rf_power_state;
168		161	if (rt_state == rf_off) {
169	if (priv->rtllib->PowerSaveControl.bInactivePs) {	162	if (priv->rtllib->rf_off_reason > RF_CHANGE_BY_IPS) {
170	if (rt_state == rf_off) {	163	netdev_warn(dev, "%s(): RF is OFF.\n",
171	if (priv->rtllib->rf_off_reason > RF_CHANGE_BY_IPS) {
172	netdev_warn(dev, "%s(): RF is OFF.\n",
173	__func__);
174	return;
175	}
176	netdev_info(dev, "=========>%s(): rtl92e_ips_leave\n",
177	__func__);	164	__func__);
178	schedule_work(&priv->rtllib->ips_leave_wq);	165	return;
179	}	166	}
		167	netdev_info(dev, "=========>%s(): rtl92e_ips_leave\n",
		168	__func__);
		169	schedule_work(&priv->rtllib->ips_leave_wq);
180	}	170	}
181	}	171	}
182		172
@@ -216,8 +206,8 @@ static bool _rtl92e_ps_set_mode(struct net_device *dev, u8 rtPsMode) · 33 unmodified lines
216	void rtl92e_leisure_ps_enter(struct net_device *dev)	206	void rtl92e_leisure_ps_enter(struct net_device *dev)
217	{	207	{
218	struct r8192_priv *priv = rtllib_priv(dev);	208	struct r8192_priv *priv = rtllib_priv(dev);
219	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )	209	struct rt_pwr_save_ctrl psc = (struct rt_pwr_save_ctrl )
220	&(priv->rtllib->PowerSaveControl);	210	&priv->rtllib->pwr_save_ctrl;
221		211
222	if (!((priv->rtllib->iw_mode == IW_MODE_INFRA) &&	212	if (!((priv->rtllib->iw_mode == IW_MODE_INFRA) &&
223	(priv->rtllib->state == RTLLIB_LINKED))	213	(priv->rtllib->state == RTLLIB_LINKED))
@@ -225,38 +215,31 @@ void rtl92e_leisure_ps_enter(struct net_device *dev) · 1 unmodified line
225	(priv->rtllib->iw_mode == IW_MODE_MASTER))	215	(priv->rtllib->iw_mode == IW_MODE_MASTER))
226	return;	216	return;
227		217
228	if (pPSC->bLeisurePs) {	218	if (psc->bLeisurePs) {
229	if (pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) {	219	if (psc->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) {
230		220
231	if (priv->rtllib->ps == RTLLIB_PS_DISABLED) {	221	if (priv->rtllib->ps == RTLLIB_PS_DISABLED) {
232	if (!pPSC->bFwCtrlLPS) {	222	if (priv->rtllib->SetFwCmdHandler)
233	if (priv->rtllib->SetFwCmdHandler)	223	priv->rtllib->SetFwCmdHandler(dev, FW_CMD_LPS_ENTER);
234	priv->rtllib->SetFwCmdHandler(
235	dev, FW_CMD_LPS_ENTER);
236	}
237	_rtl92e_ps_set_mode(dev, RTLLIB_PS_MBCAST \|	224	_rtl92e_ps_set_mode(dev, RTLLIB_PS_MBCAST \|
238	RTLLIB_PS_UNICAST);	225	RTLLIB_PS_UNICAST);
239	}	226	}
240	} else	227	} else
241	pPSC->LpsIdleCount++;	228	psc->LpsIdleCount++;
242	}	229	}
243	}	230	}
244		231
245	void rtl92e_leisure_ps_leave(struct net_device *dev)	232	void rtl92e_leisure_ps_leave(struct net_device *dev)
246	{	233	{
247	struct r8192_priv *priv = rtllib_priv(dev);	234	struct r8192_priv *priv = rtllib_priv(dev);
248	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )	235	struct rt_pwr_save_ctrl psc = (struct rt_pwr_save_ctrl )
249	&(priv->rtllib->PowerSaveControl);	236	&priv->rtllib->pwr_save_ctrl;
250		237
251	if (pPSC->bLeisurePs) {	238	if (psc->bLeisurePs) {
252	if (priv->rtllib->ps != RTLLIB_PS_DISABLED) {	239	if (priv->rtllib->ps != RTLLIB_PS_DISABLED) {
253	_rtl92e_ps_set_mode(dev, RTLLIB_PS_DISABLED);	240	_rtl92e_ps_set_mode(dev, RTLLIB_PS_DISABLED);
254		241	if (priv->rtllib->SetFwCmdHandler)
255	if (!pPSC->bFwCtrlLPS) {	242	priv->rtllib->SetFwCmdHandler(dev, FW_CMD_LPS_LEAVE);
256	if (priv->rtllib->SetFwCmdHandler)
257	priv->rtllib->SetFwCmdHandler(dev,
258	FW_CMD_LPS_LEAVE);
259	}
260	}	243	}
261	}	244	}
262	}	245	}

drivers/staging/rtl8192e/rtl8192e/rtl_wx.c+45−49

 					   union iwreq_data *wrqu, char *extra)
 {
 	struct r8192_priv *priv = rtllib_priv(dev);
-	struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
+	struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *)
-					(&priv->rtllib->PowerSaveControl);
+					(&priv->rtllib->pwr_save_ctrl);
 	struct rtllib_device *ieee = priv->rtllib;
 	mutex_lock(&priv->wx_mutex);
 	if (*extra || priv->force_lps) {
 		priv->ps_force = false;
-		pPSC->bLeisurePs = true;
+		psc->bLeisurePs = true;
 	} else {
 		if (priv->rtllib->state == RTLLIB_LINKED)
 			rtl92e_leisure_ps_leave(dev);
 		priv->ps_force = true;
-		pPSC->bLeisurePs = false;
+		psc->bLeisurePs = false;
 		ieee->ps = *extra;
 	}
 					     char *extra)
 {
 	struct r8192_priv *priv = rtllib_priv(dev);
-	struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
+	struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *)
-					(&priv->rtllib->PowerSaveControl);
+					(&priv->rtllib->pwr_save_ctrl);
 	mutex_lock(&priv->wx_mutex);
 	netdev_info(dev, "%s(): set lps awake interval ! extra is %d\n",
 		    __func__, *extra);
-	pPSC->RegMaxLPSAwakeIntvl = *extra;
+	psc->reg_max_lps_awake_intvl = *extra;
 	mutex_unlock(&priv->wx_mutex);
 	return 0;
 }
 	rt_state = priv->rtllib->rf_power_state;
 	mutex_lock(&priv->wx_mutex);
 	if (wrqu->mode == IW_MODE_ADHOC || wrqu->mode == IW_MODE_MONITOR ||
-	    ieee->bNetPromiscuousMode) {
+	    ieee->net_promiscuous_md) {
-		if (priv->rtllib->PowerSaveControl.bInactivePs) {
+		if (rt_state == rf_off) {
-			if (rt_state == rf_off) {
+			if (priv->rtllib->rf_off_reason >
-				if (priv->rtllib->rf_off_reason >
+			    RF_CHANGE_BY_IPS) {
-				    RF_CHANGE_BY_IPS) {
+				netdev_warn(dev, "%s(): RF is OFF.\n",
-					netdev_warn(dev, "%s(): RF is OFF.\n",
-						    __func__);
-					mutex_unlock(&priv->wx_mutex);
-					return -1;
-				}
-				netdev_info(dev,
-					    "=========>%s(): rtl92e_ips_leave\n",
 					    __func__);
-				mutex_lock(&priv->rtllib->ips_mutex);
+				mutex_unlock(&priv->wx_mutex);
-				rtl92e_ips_leave(dev);
+				return -1;
-				mutex_unlock(&priv->rtllib->ips_mutex);
 			}
+			netdev_info(dev,
+				    "=========>%s(): rtl92e_ips_leave\n",
+				    __func__);
+			mutex_lock(&priv->rtllib->ips_mutex);
+			rtl92e_ips_leave(dev);
+			mutex_unlock(&priv->rtllib->ips_mutex);
 		}
 	}
 	ret = rtllib_wx_set_mode(priv->rtllib, a, wrqu, b);
 	rt_state = priv->rtllib->rf_power_state;
 	if (!priv->up)
 		return -ENETDOWN;
-	if (priv->rtllib->LinkDetectInfo.bBusyTraffic == true)
+	if (priv->rtllib->link_detect_info.bBusyTraffic == true)
 		return -EAGAIN;
 	if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
 	priv->rtllib->FirstIe_InScan = true;
 	if (priv->rtllib->state != RTLLIB_LINKED) {
-		if (priv->rtllib->PowerSaveControl.bInactivePs) {
+		if (rt_state == rf_off) {
-			if (rt_state == rf_off) {
+			if (priv->rtllib->rf_off_reason >
-				if (priv->rtllib->rf_off_reason >
+			    RF_CHANGE_BY_IPS) {
-				    RF_CHANGE_BY_IPS) {
+				netdev_warn(dev, "%s(): RF is OFF.\n",
-					netdev_warn(dev, "%s(): RF is OFF.\n",
+					    __func__);
-						    __func__);
+				mutex_unlock(&priv->wx_mutex);
-					mutex_unlock(&priv->wx_mutex);
+				return -1;
-					return -1;
-				}
-				mutex_lock(&priv->rtllib->ips_mutex);
-				rtl92e_ips_leave(dev);
-				mutex_unlock(&priv->rtllib->ips_mutex);
 			}
+			mutex_lock(&priv->rtllib->ips_mutex);
+			rtl92e_ips_leave(dev);
+			mutex_unlock(&priv->rtllib->ips_mutex);
 		}
 		rtllib_stop_scan(priv->rtllib);
 		if (priv->rtllib->LedControlHandler)
 					 key, 0);
 		} else {
 			if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) &&
-			     ieee->pHTInfo->bCurrentHTSupport)
+			     ieee->ht_info->bCurrentHTSupport)
 				rtl92e_writeb(dev, 0x173, 1);
 			rtl92e_set_key(dev, 4, idx, alg,
 				       (u8 *)ieee->ap_mac_addr, 0, key);
 	u32 info_buf[3];
 	u32 oid;
-	u32 bPromiscuousOn;
+	u32 promiscuous_on;
-	u32 bFilterSourceStationFrame;
+	u32 fltr_src_sta_frame;
 	if (copy_from_user(info_buf, wrqu->data.pointer, sizeof(info_buf)))
 		return -EFAULT;
 	oid = info_buf[0];
-	bPromiscuousOn = info_buf[1];
+	promiscuous_on = info_buf[1];
-	bFilterSourceStationFrame = info_buf[2];
+	fltr_src_sta_frame = info_buf[2];
 	if (oid == OID_RT_INTEL_PROMISCUOUS_MODE) {
-		ieee->IntelPromiscuousModeInfo.bPromiscuousOn =
+		ieee->intel_promiscuous_md_info.promiscuous_on =
-					(bPromiscuousOn) ? (true) : (false);
+					(promiscuous_on) ? (true) : (false);
-		ieee->IntelPromiscuousModeInfo.bFilterSourceStationFrame =
+		ieee->intel_promiscuous_md_info.fltr_src_sta_frame =
-			(bFilterSourceStationFrame) ? (true) : (false);
+			(fltr_src_sta_frame) ? (true) : (false);
-		(bPromiscuousOn) ?
+		(promiscuous_on) ?
 		(rtllib_EnableIntelPromiscuousMode(dev, false)) :
 		(rtllib_DisableIntelPromiscuousMode(dev, false));
 		netdev_info(dev,
 			    "=======>%s(), on = %d, filter src sta = %d\n",
-			    __func__, bPromiscuousOn,
+			    __func__, promiscuous_on,
-			    bFilterSourceStationFrame);
+			    fltr_src_sta_frame);
 	} else {
 		return -1;
 	}
 	mutex_lock(&priv->wx_mutex);
 	snprintf(extra, 45, "PromiscuousMode:%d, FilterSrcSTAFrame:%d",
-		 ieee->IntelPromiscuousModeInfo.bPromiscuousOn,
+		 ieee->intel_promiscuous_md_info.promiscuous_on,
-		 ieee->IntelPromiscuousModeInfo.bFilterSourceStationFrame);
+		 ieee->intel_promiscuous_md_info.fltr_src_sta_frame);
 	wrqu->data.length = strlen(extra) + 1;
 	mutex_unlock(&priv->wx_mutex);

drivers/staging/rtl8192e/rtl819x_BAProc.c+18−20

 	pBA->dialog_token		  = 0;
 	pBA->ba_start_seq_ctrl.short_data = 0;
 }
 static struct sk_buff *rtllib_ADDBA(struct rtllib_device *ieee, u8 *Dst,
 				    struct ba_record *pBA,
 				    u16 StatusCode, u8 type)
 	tag += 2;
 	if (type == ACT_ADDBAREQ) {
-		memcpy(tag, (u8 *)&(pBA->ba_start_seq_ctrl), 2);
+		memcpy(tag, (u8 *)&pBA->ba_start_seq_ctrl, 2);
 		tag += 2;
 	}
 	*tag++ = ACT_CAT_BA;
 	*tag++ = ACT_DELBA;
 	put_unaligned_le16(DelbaParamSet.short_data, tag);
 	tag += 2;
 	skb = rtllib_ADDBA(ieee, dst, pBA, 0, ACT_ADDBAREQ);
-	if (skb) {
+	if (skb)
 		softmac_mgmt_xmit(skb, ieee);
-	} else {
+	else
 		netdev_dbg(ieee->dev, "Failed to generate ADDBAReq packet.\n");
-	}
 }
 static void rtllib_send_ADDBARsp(struct rtllib_device *ieee, u8 *dst,
 	pBaStartSeqCtrl = (union sequence_control *)(req + 7);
 	if (!ieee->current_network.qos_data.active ||
-	    !ieee->pHTInfo->bCurrentHTSupport ||
+	    !ieee->ht_info->bCurrentHTSupport ||
-	    (ieee->pHTInfo->iot_action & HT_IOT_ACT_REJECT_ADDBA_REQ)) {
+	    (ieee->ht_info->iot_action & HT_IOT_ACT_REJECT_ADDBA_REQ)) {
 		rc = ADDBA_STATUS_REFUSED;
 		netdev_warn(ieee->dev,
 			    "Failed to reply on ADDBA_REQ as some capability is not ready(%d, %d)\n",
 			    ieee->current_network.qos_data.active,
-			    ieee->pHTInfo->bCurrentHTSupport);
+			    ieee->ht_info->bCurrentHTSupport);
 		goto OnADDBAReq_Fail;
 	}
-	if (!GetTs(ieee, (struct ts_common_info **)(&pTS), dst,
+	if (!GetTs(ieee, (struct ts_common_info **)&pTS, dst,
-	    (u8)(pBaParamSet->field.tid), RX_DIR, true)) {
+		   (u8)(pBaParamSet->field.tid), RX_DIR, true)) {
 		rc = ADDBA_STATUS_REFUSED;
 		netdev_warn(ieee->dev, "%s(): can't get TS\n", __func__);
 		goto OnADDBAReq_Fail;
 	pBA->ba_start_seq_ctrl = *pBaStartSeqCtrl;
 	if (ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev) ||
-	   (ieee->pHTInfo->iot_action & HT_IOT_ACT_ALLOW_PEER_AGG_ONE_PKT))
+	   (ieee->ht_info->iot_action & HT_IOT_ACT_ALLOW_PEER_AGG_ONE_PKT))
 		pBA->ba_param_set.field.buffer_size = 1;
 	else
 		pBA->ba_param_set.field.buffer_size = 32;
 	pBaTimeoutVal = (u16 *)(tag + 7);
 	if (!ieee->current_network.qos_data.active ||
-	    !ieee->pHTInfo->bCurrentHTSupport ||
+	    !ieee->ht_info->bCurrentHTSupport ||
-	    !ieee->pHTInfo->bCurrentAMPDUEnable) {
+	    !ieee->ht_info->bCurrentAMPDUEnable) {
 		netdev_warn(ieee->dev,
 			    "reject to ADDBA_RSP as some capability is not ready(%d, %d, %d)\n",
 			    ieee->current_network.qos_data.active,
-			    ieee->pHTInfo->bCurrentHTSupport,
+			    ieee->ht_info->bCurrentHTSupport,
-			    ieee->pHTInfo->bCurrentAMPDUEnable);
+			    ieee->ht_info->bCurrentAMPDUEnable);
 		ReasonCode = DELBA_REASON_UNKNOWN_BA;
 		goto OnADDBARsp_Reject;
 	}
-	if (!GetTs(ieee, (struct ts_common_info **)(&pTS), dst,
+	if (!GetTs(ieee, (struct ts_common_info **)&pTS, dst,
 		   (u8)(pBaParamSet->field.tid), TX_DIR, false)) {
 		netdev_warn(ieee->dev, "%s(): can't get TS\n", __func__);
 		ReasonCode = DELBA_REASON_UNKNOWN_BA;
 			goto OnADDBARsp_Reject;
 		}
 		pAdmittedBA->dialog_token = *pDialogToken;
 		pAdmittedBA->ba_timeout_value = *pBaTimeoutVal;
 		pAdmittedBA->ba_start_seq_ctrl = pPendingBA->ba_start_seq_ctrl;
 	}
 	if (!ieee->current_network.qos_data.active ||
-		!ieee->pHTInfo->bCurrentHTSupport) {
+	    !ieee->ht_info->bCurrentHTSupport) {
 		netdev_warn(ieee->dev,
 			    "received DELBA while QOS or HT is not supported(%d, %d)\n",
 			    ieee->current_network. qos_data.active,
-			    ieee->pHTInfo->bCurrentHTSupport);
+			    ieee->ht_info->bCurrentHTSupport);
 		return -1;
 	}
 		struct rx_ts_record *pRxTs;
 		if (!GetTs(ieee, (struct ts_common_info **)&pRxTs, dst,
-		    (u8)pDelBaParamSet->field.tid, RX_DIR, false)) {
+			   (u8)pDelBaParamSet->field.tid, RX_DIR, false)) {
 			netdev_warn(ieee->dev,
 				    "%s(): can't get TS for RXTS. dst:%pM TID:%d\n",
 				    __func__, dst,

drivers/staging/rtl8192e/rtl819x_HT.h+1−1

@@ -96,7 +96,7 @@ enum ht_aggre_mode { · 95 unmodified lines
96		96
97		97
98	struct rt_hi_throughput {	98	struct rt_hi_throughput {
99	u8 bEnableHT;	99	u8 enable_ht;
100	u8 bCurrentHTSupport;	100	u8 bCurrentHTSupport;
101		101
102	u8 bRegBW40MHz;	102	u8 bRegBW40MHz;

drivers/staging/rtl8192e/rtl819x_HTProc.c+201−204

@@ -69,47 +69,48 @@ static u8 LINKSYS_MARVELL_4400N[3] = {0x00, 0x14, 0xa4}; · 68 unmodified lines
69		69
70	void HTUpdateDefaultSetting(struct rtllib_device *ieee)	70	void HTUpdateDefaultSetting(struct rtllib_device *ieee)
71	{	71	{
72	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	72	struct rt_hi_throughput *ht_info = ieee->ht_info;
73	pHTInfo->bRegShortGI20MHz = 1;
74	pHTInfo->bRegShortGI40MHz = 1;
75		73
76	pHTInfo->bRegBW40MHz = 1;	74	ht_info->bRegShortGI20MHz = 1;
		75	ht_info->bRegShortGI40MHz = 1;
77		76
78	if (pHTInfo->bRegBW40MHz)	77	ht_info->bRegBW40MHz = 1;
79	pHTInfo->bRegSuppCCK = 1;	78
		79	if (ht_info->bRegBW40MHz)
		80	ht_info->bRegSuppCCK = 1;
80	else	81	else
81	pHTInfo->bRegSuppCCK = true;	82	ht_info->bRegSuppCCK = true;
82		83
83	pHTInfo->nAMSDU_MaxSize = 7935UL;	84	ht_info->nAMSDU_MaxSize = 7935UL;
84	pHTInfo->bAMSDU_Support = 0;	85	ht_info->bAMSDU_Support = 0;
85		86
86	pHTInfo->bAMPDUEnable = 1;	87	ht_info->bAMPDUEnable = 1;
87	pHTInfo->AMPDU_Factor = 2;	88	ht_info->AMPDU_Factor = 2;
88	pHTInfo->MPDU_Density = 0;	89	ht_info->MPDU_Density = 0;
89		90
90	pHTInfo->self_mimo_ps = 3;	91	ht_info->self_mimo_ps = 3;
91	if (pHTInfo->self_mimo_ps == 2)	92	if (ht_info->self_mimo_ps == 2)
92	pHTInfo->self_mimo_ps = 3;	93	ht_info->self_mimo_ps = 3;
93	ieee->bTxDisableRateFallBack = 0;	94	ieee->tx_dis_rate_fallback = 0;
94	ieee->bTxUseDriverAssingedRate = 0;	95	ieee->tx_use_drv_assinged_rate = 0;
95		96
96	ieee->bTxEnableFwCalcDur = 1;	97	ieee->bTxEnableFwCalcDur = 1;
97		98
98	pHTInfo->reg_rt2rt_aggregation = 1;	99	ht_info->reg_rt2rt_aggregation = 1;
99		100
100	pHTInfo->reg_rx_reorder_enable = 1;	101	ht_info->reg_rx_reorder_enable = 1;
101	pHTInfo->rx_reorder_win_size = 64;	102	ht_info->rx_reorder_win_size = 64;
102	pHTInfo->rx_reorder_pending_time = 30;	103	ht_info->rx_reorder_pending_time = 30;
103	}	104	}
104		105
105	static u16 HTMcsToDataRate(struct rtllib_device *ieee, u8 nMcsRate)	106	static u16 HTMcsToDataRate(struct rtllib_device *ieee, u8 nMcsRate)
106	{	107	{
107	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	108	struct rt_hi_throughput *ht_info = ieee->ht_info;
108		109
109	u8 is40MHz = (pHTInfo->bCurBW40MHz) ? 1 : 0;	110	u8 is40MHz = (ht_info->bCurBW40MHz) ? 1 : 0;
110	u8 isShortGI = (pHTInfo->bCurBW40MHz) ?	111	u8 isShortGI = (ht_info->bCurBW40MHz) ?
111	((pHTInfo->bCurShortGI40MHz) ? 1 : 0) :	112	((ht_info->bCurShortGI40MHz) ? 1 : 0) :
112	((pHTInfo->bCurShortGI20MHz) ? 1 : 0);	113	((ht_info->bCurShortGI20MHz) ? 1 : 0);
113	return MCS_DATA_RATE[is40MHz][isShortGI][(nMcsRate & 0x7f)];	114	return MCS_DATA_RATE[is40MHz][isShortGI][(nMcsRate & 0x7f)];
114	}	115	}
115		116
@@ -151,8 +152,8 @@ bool IsHTHalfNmodeAPs(struct rtllib_device *ieee) · 35 unmodified lines
151	(net->ralink_cap_exist))	152	(net->ralink_cap_exist))
152	retValue = true;	153	retValue = true;
153	else if (!memcmp(net->bssid, UNKNOWN_BORADCOM, 3) \|\|	154	else if (!memcmp(net->bssid, UNKNOWN_BORADCOM, 3) \|\|
154	!memcmp(net->bssid, LINKSYSWRT330_LINKSYSWRT300_BROADCOM, 3) \|\|	155	!memcmp(net->bssid, LINKSYSWRT330_LINKSYSWRT300_BROADCOM, 3) \|\|
155	!memcmp(net->bssid, LINKSYSWRT350_LINKSYSWRT150_BROADCOM, 3) \|\|	156	!memcmp(net->bssid, LINKSYSWRT350_LINKSYSWRT150_BROADCOM, 3) \|\|
156	(net->broadcom_cap_exist))	157	(net->broadcom_cap_exist))
157	retValue = true;	158	retValue = true;
158	else if (net->bssht.bd_rt2rt_aggregation)	159	else if (net->bssht.bd_rt2rt_aggregation)
@@ -165,45 +166,45 @@ bool IsHTHalfNmodeAPs(struct rtllib_device *ieee) · 6 unmodified lines
165		166
166	static void HTIOTPeerDetermine(struct rtllib_device *ieee)	167	static void HTIOTPeerDetermine(struct rtllib_device *ieee)
167	{	168	{
168	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	169	struct rt_hi_throughput *ht_info = ieee->ht_info;
169	struct rtllib_network *net = &ieee->current_network;	170	struct rtllib_network *net = &ieee->current_network;
170		171
171	if (net->bssht.bd_rt2rt_aggregation) {	172	if (net->bssht.bd_rt2rt_aggregation) {
172	pHTInfo->IOTPeer = HT_IOT_PEER_REALTEK;	173	ht_info->IOTPeer = HT_IOT_PEER_REALTEK;
173	if (net->bssht.rt2rt_ht_mode & RT_HT_CAP_USE_92SE)	174	if (net->bssht.rt2rt_ht_mode & RT_HT_CAP_USE_92SE)
174	pHTInfo->IOTPeer = HT_IOT_PEER_REALTEK_92SE;	175	ht_info->IOTPeer = HT_IOT_PEER_REALTEK_92SE;
175	if (net->bssht.rt2rt_ht_mode & RT_HT_CAP_USE_SOFTAP)	176	if (net->bssht.rt2rt_ht_mode & RT_HT_CAP_USE_SOFTAP)
176	pHTInfo->IOTPeer = HT_IOT_PEER_92U_SOFTAP;	177	ht_info->IOTPeer = HT_IOT_PEER_92U_SOFTAP;
177	} else if (net->broadcom_cap_exist) {	178	} else if (net->broadcom_cap_exist) {
178	pHTInfo->IOTPeer = HT_IOT_PEER_BROADCOM;	179	ht_info->IOTPeer = HT_IOT_PEER_BROADCOM;
179	} else if (!memcmp(net->bssid, UNKNOWN_BORADCOM, 3) \|\|	180	} else if (!memcmp(net->bssid, UNKNOWN_BORADCOM, 3) \|\|
180	!memcmp(net->bssid, LINKSYSWRT330_LINKSYSWRT300_BROADCOM, 3) \|\|	181	!memcmp(net->bssid, LINKSYSWRT330_LINKSYSWRT300_BROADCOM, 3) \|\|
181	!memcmp(net->bssid, LINKSYSWRT350_LINKSYSWRT150_BROADCOM, 3)) {	182	!memcmp(net->bssid, LINKSYSWRT350_LINKSYSWRT150_BROADCOM, 3)) {
182	pHTInfo->IOTPeer = HT_IOT_PEER_BROADCOM;	183	ht_info->IOTPeer = HT_IOT_PEER_BROADCOM;
183	} else if ((memcmp(net->bssid, BELKINF5D8233V1_RALINK, 3) == 0) \|\|	184	} else if ((memcmp(net->bssid, BELKINF5D8233V1_RALINK, 3) == 0) \|\|
184	(memcmp(net->bssid, BELKINF5D82334V3_RALINK, 3) == 0) \|\|	185	(memcmp(net->bssid, BELKINF5D82334V3_RALINK, 3) == 0) \|\|
185	(memcmp(net->bssid, PCI_RALINK, 3) == 0) \|\|	186	(memcmp(net->bssid, PCI_RALINK, 3) == 0) \|\|
186	(memcmp(net->bssid, EDIMAX_RALINK, 3) == 0) \|\|	187	(memcmp(net->bssid, EDIMAX_RALINK, 3) == 0) \|\|
187	(memcmp(net->bssid, AIRLINK_RALINK, 3) == 0) \|\|	188	(memcmp(net->bssid, AIRLINK_RALINK, 3) == 0) \|\|
188	net->ralink_cap_exist) {	189	net->ralink_cap_exist) {
189	pHTInfo->IOTPeer = HT_IOT_PEER_RALINK;	190	ht_info->IOTPeer = HT_IOT_PEER_RALINK;
190	} else if ((net->atheros_cap_exist) \|\|	191	} else if ((net->atheros_cap_exist) \|\|
191	(memcmp(net->bssid, DLINK_ATHEROS_1, 3) == 0) \|\|	192	(memcmp(net->bssid, DLINK_ATHEROS_1, 3) == 0) \|\|
192	(memcmp(net->bssid, DLINK_ATHEROS_2, 3) == 0)) {	193	(memcmp(net->bssid, DLINK_ATHEROS_2, 3) == 0)) {
193	pHTInfo->IOTPeer = HT_IOT_PEER_ATHEROS;	194	ht_info->IOTPeer = HT_IOT_PEER_ATHEROS;
194	} else if ((memcmp(net->bssid, CISCO_BROADCOM, 3) == 0) \|\|	195	} else if ((memcmp(net->bssid, CISCO_BROADCOM, 3) == 0) \|\|
195	net->cisco_cap_exist) {	196	net->cisco_cap_exist) {
196	pHTInfo->IOTPeer = HT_IOT_PEER_CISCO;	197	ht_info->IOTPeer = HT_IOT_PEER_CISCO;
197	} else if ((memcmp(net->bssid, LINKSYS_MARVELL_4400N, 3) == 0) \|\|	198	} else if ((memcmp(net->bssid, LINKSYS_MARVELL_4400N, 3) == 0) \|\|
198	net->marvell_cap_exist) {	199	net->marvell_cap_exist) {
199	pHTInfo->IOTPeer = HT_IOT_PEER_MARVELL;	200	ht_info->IOTPeer = HT_IOT_PEER_MARVELL;
200	} else if (net->airgo_cap_exist) {	201	} else if (net->airgo_cap_exist) {
201	pHTInfo->IOTPeer = HT_IOT_PEER_AIRGO;	202	ht_info->IOTPeer = HT_IOT_PEER_AIRGO;
202	} else {	203	} else {
203	pHTInfo->IOTPeer = HT_IOT_PEER_UNKNOWN;	204	ht_info->IOTPeer = HT_IOT_PEER_UNKNOWN;
204	}	205	}
205		206
206	netdev_dbg(ieee->dev, "IOTPEER: %x\n", pHTInfo->IOTPeer);	207	netdev_dbg(ieee->dev, "IOTPEER: %x\n", ht_info->IOTPeer);
207	}	208	}
208		209
209	static u8 HTIOTActIsDisableMCS14(struct rtllib_device ieee, u8 PeerMacAddr)	210	static u8 HTIOTActIsDisableMCS14(struct rtllib_device ieee, u8 PeerMacAddr)
@@ -232,7 +233,7 @@ static u8 HTIOTActIsMgntUseCCK6M(struct rtllib_device *ieee, · 22 unmodified lines
232	{	233	{
233	u8 retValue = 0;	234	u8 retValue = 0;
234		235
235	if (ieee->pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM)	236	if (ieee->ht_info->IOTPeer == HT_IOT_PEER_BROADCOM)
236	retValue = 1;	237	retValue = 1;
237		238
238	return retValue;	239	return retValue;
@@ -242,49 +243,49 @@ static u8 HTIOTActIsCCDFsync(struct rtllib_device *ieee) · 3 unmodified lines
242	{	243	{
243	u8 retValue = 0;	244	u8 retValue = 0;
244		245
245	if (ieee->pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM)	246	if (ieee->ht_info->IOTPeer == HT_IOT_PEER_BROADCOM)
246	retValue = 1;	247	retValue = 1;
247	return retValue;	248	return retValue;
248	}	249	}
249		250
250	static void HTIOTActDetermineRaFunc(struct rtllib_device *ieee, bool bPeerRx2ss)	251	static void HTIOTActDetermineRaFunc(struct rtllib_device *ieee, bool bPeerRx2ss)
251	{	252	{
252	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	253	struct rt_hi_throughput *ht_info = ieee->ht_info;
253		254
254	pHTInfo->iot_ra_func &= HT_IOT_RAFUNC_DISABLE_ALL;	255	ht_info->iot_ra_func &= HT_IOT_RAFUNC_DISABLE_ALL;
255		256
256	if (pHTInfo->IOTPeer == HT_IOT_PEER_RALINK && !bPeerRx2ss)	257	if (ht_info->IOTPeer == HT_IOT_PEER_RALINK && !bPeerRx2ss)
257	pHTInfo->iot_ra_func \|= HT_IOT_RAFUNC_PEER_1R;	258	ht_info->iot_ra_func \|= HT_IOT_RAFUNC_PEER_1R;
258		259
259	if (pHTInfo->iot_action & HT_IOT_ACT_AMSDU_ENABLE)	260	if (ht_info->iot_action & HT_IOT_ACT_AMSDU_ENABLE)
260	pHTInfo->iot_ra_func \|= HT_IOT_RAFUNC_TX_AMSDU;	261	ht_info->iot_ra_func \|= HT_IOT_RAFUNC_TX_AMSDU;
261	}	262	}
262		263
263	void HTResetIOTSetting(struct rt_hi_throughput *pHTInfo)	264	void HTResetIOTSetting(struct rt_hi_throughput *ht_info)
264	{	265	{
265	pHTInfo->iot_action = 0;	266	ht_info->iot_action = 0;
266	pHTInfo->IOTPeer = HT_IOT_PEER_UNKNOWN;	267	ht_info->IOTPeer = HT_IOT_PEER_UNKNOWN;
267	pHTInfo->iot_ra_func = 0;	268	ht_info->iot_ra_func = 0;
268	}	269	}
269		270
270	void HTConstructCapabilityElement(struct rtllib_device ieee, u8 posHTCap,	271	void HTConstructCapabilityElement(struct rtllib_device ieee, u8 posHTCap,
271	u8 *len, u8 IsEncrypt, bool bAssoc)	272	u8 *len, u8 IsEncrypt, bool bAssoc)
272	{	273	{
273	struct rt_hi_throughput *pHT = ieee->pHTInfo;	274	struct rt_hi_throughput *pHT = ieee->ht_info;
274	struct ht_capab_ele *pCapELE = NULL;	275	struct ht_capab_ele *pCapELE = NULL;
275		276
276	if (!posHTCap \|\| !pHT) {	277	if (!posHTCap \|\| !pHT) {
277	netdev_warn(ieee->dev,	278	netdev_warn(ieee->dev,
278	"%s(): posHTCap and pHTInfo are null\n", __func__);	279	"%s(): posHTCap and ht_info are null\n", __func__);
279	return;	280	return;
280	}	281	}
281	memset(posHTCap, 0, *len);	282	memset(posHTCap, 0, *len);
282		283
283	if ((bAssoc) && (pHT->ePeerHTSpecVer == HT_SPEC_VER_EWC)) {	284	if ((bAssoc) && (pHT->ePeerHTSpecVer == HT_SPEC_VER_EWC)) {
284	u8 EWC11NHTCap[] = {0x00, 0x90, 0x4c, 0x33};	285	static const u8 EWC11NHTCap[] = { 0x00, 0x90, 0x4c, 0x33 };
285		286
286	memcpy(posHTCap, EWC11NHTCap, sizeof(EWC11NHTCap));	287	memcpy(posHTCap, EWC11NHTCap, sizeof(EWC11NHTCap));
287	pCapELE = (struct ht_capab_ele *)&(posHTCap[4]);	288	pCapELE = (struct ht_capab_ele *)&posHTCap[4];
288	*len = 30 + 2;	289	*len = 30 + 2;
289	} else {	290	} else {
290	pCapELE = (struct ht_capab_ele *)posHTCap;	291	pCapELE = (struct ht_capab_ele *)posHTCap;
@@ -322,7 +323,7 @@ void HTConstructCapabilityElement(struct rtllib_device ieee, u8 posHTCap, · 31 unmodified lines
322	pCapELE->MPDUDensity = 0;	323	pCapELE->MPDUDensity = 0;
323	}	324	}
324		325
325	memcpy(pCapELE->MCS, ieee->Regdot11HTOperationalRateSet, 16);	326	memcpy(pCapELE->MCS, ieee->reg_dot11ht_oper_rate_set, 16);
326	memset(&pCapELE->ExtHTCapInfo, 0, 2);	327	memset(&pCapELE->ExtHTCapInfo, 0, 2);
327	memset(pCapELE->TxBFCap, 0, 4);	328	memset(pCapELE->TxBFCap, 0, 4);
328		329
@@ -351,7 +352,7 @@ void HTConstructCapabilityElement(struct rtllib_device ieee, u8 posHTCap, · 22 unmodified lines
351	void HTConstructInfoElement(struct rtllib_device ieee, u8 posHTInfo,	352	void HTConstructInfoElement(struct rtllib_device ieee, u8 posHTInfo,
352	u8 *len, u8 IsEncrypt)	353	u8 *len, u8 IsEncrypt)
353	{	354	{
354	struct rt_hi_throughput *pHT = ieee->pHTInfo;	355	struct rt_hi_throughput *pHT = ieee->ht_info;
355	struct ht_info_ele pHTInfoEle = (struct ht_info_ele )posHTInfo;	356	struct ht_info_ele pHTInfoEle = (struct ht_info_ele )posHTInfo;
356		357
357	if (!posHTInfo \|\| !pHTInfoEle) {	358	if (!posHTInfo \|\| !pHTInfoEle) {
@@ -488,7 +489,7 @@ static u8 HTFilterMCSRate(struct rtllib_device ieee, u8 pSupportMCS, · 130 unmodified lines
488	u8 i;	489	u8 i;
489		490
490	for (i = 0; i <= 15; i++)	491	for (i = 0; i <= 15; i++)
491	pOperateMCS[i] = ieee->Regdot11TxHTOperationalRateSet[i] &	492	pOperateMCS[i] = ieee->reg_dot11tx_ht_oper_rate_set[i] &
492	pSupportMCS[i];	493	pSupportMCS[i];
493		494
494	HT_PickMCSRate(ieee, pOperateMCS);	495	HT_PickMCSRate(ieee, pOperateMCS);
@@ -508,163 +509,159 @@ void HTSetConnectBwMode(struct rtllib_device *ieee, · 13 unmodified lines
508		509
509	void HTOnAssocRsp(struct rtllib_device *ieee)	510	void HTOnAssocRsp(struct rtllib_device *ieee)
510	{	511	{
511	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	512	struct rt_hi_throughput *ht_info = ieee->ht_info;
512	struct ht_capab_ele *pPeerHTCap = NULL;	513	struct ht_capab_ele *pPeerHTCap = NULL;
513	struct ht_info_ele *pPeerHTInfo = NULL;	514	struct ht_info_ele *pPeerHTInfo = NULL;
514	u16 nMaxAMSDUSize = 0;	515	u16 nMaxAMSDUSize = 0;
515	u8 *pMcsFilter = NULL;	516	u8 *pMcsFilter = NULL;
516		517
517	static u8 EWC11NHTCap[] = {0x00, 0x90, 0x4c, 0x33};	518	static const u8 EWC11NHTCap[] = { 0x00, 0x90, 0x4c, 0x33 };
518	static u8 EWC11NHTInfo[] = {0x00, 0x90, 0x4c, 0x34};	519	static const u8 EWC11NHTInfo[] = { 0x00, 0x90, 0x4c, 0x34 };
519		520
520	if (!pHTInfo->bCurrentHTSupport) {	521	if (!ht_info->bCurrentHTSupport) {
521	netdev_warn(ieee->dev, "%s(): HT_DISABLE\n", __func__);	522	netdev_warn(ieee->dev, "%s(): HT_DISABLE\n", __func__);
522	return;	523	return;
523	}	524	}
524	netdev_dbg(ieee->dev, "%s(): HT_ENABLE\n", __func__);	525	netdev_dbg(ieee->dev, "%s(): HT_ENABLE\n", __func__);
525		526
526	if (!memcmp(pHTInfo->PeerHTCapBuf, EWC11NHTCap, sizeof(EWC11NHTCap)))	527	if (!memcmp(ht_info->PeerHTCapBuf, EWC11NHTCap, sizeof(EWC11NHTCap)))
527	pPeerHTCap = (struct ht_capab_ele *)(&pHTInfo->PeerHTCapBuf[4]);	528	pPeerHTCap = (struct ht_capab_ele *)(&ht_info->PeerHTCapBuf[4]);
528	else	529	else
529	pPeerHTCap = (struct ht_capab_ele *)(pHTInfo->PeerHTCapBuf);	530	pPeerHTCap = (struct ht_capab_ele *)(ht_info->PeerHTCapBuf);
530		531
531	if (!memcmp(pHTInfo->PeerHTInfoBuf, EWC11NHTInfo, sizeof(EWC11NHTInfo)))	532	if (!memcmp(ht_info->PeerHTInfoBuf, EWC11NHTInfo, sizeof(EWC11NHTInfo)))
532	pPeerHTInfo = (struct ht_info_ele *)	533	pPeerHTInfo = (struct ht_info_ele *)
533	(&pHTInfo->PeerHTInfoBuf[4]);	534	(&ht_info->PeerHTInfoBuf[4]);
534	else	535	else
535	pPeerHTInfo = (struct ht_info_ele *)(pHTInfo->PeerHTInfoBuf);	536	pPeerHTInfo = (struct ht_info_ele *)(ht_info->PeerHTInfoBuf);
536		537
537	#ifdef VERBOSE_DEBUG	538	#ifdef VERBOSE_DEBUG
538	print_hex_dump_bytes("%s: ", __func__, DUMP_PREFIX_NONE,	539	print_hex_dump_bytes("%s: ", __func__, DUMP_PREFIX_NONE,
539	pPeerHTCap, sizeof(struct ht_capab_ele));	540	pPeerHTCap, sizeof(struct ht_capab_ele));
540	#endif	541	#endif
541	HTSetConnectBwMode(ieee, (enum ht_channel_width)(pPeerHTCap->ChlWidth),	542	HTSetConnectBwMode(ieee, (enum ht_channel_width)(pPeerHTCap->ChlWidth),
542	(enum ht_extchnl_offset)(pPeerHTInfo->ExtChlOffset));	543	(enum ht_extchnl_offset)(pPeerHTInfo->ExtChlOffset));
543	pHTInfo->cur_tx_bw40mhz = ((pPeerHTInfo->RecommemdedTxWidth == 1) ?	544	ht_info->cur_tx_bw40mhz = ((pPeerHTInfo->RecommemdedTxWidth == 1) ?
544	true : false);	545	true : false);
545		546
546	pHTInfo->bCurShortGI20MHz = ((pHTInfo->bRegShortGI20MHz) ?	547	ht_info->bCurShortGI20MHz = ((ht_info->bRegShortGI20MHz) ?
547	((pPeerHTCap->ShortGI20Mhz == 1) ?	548	((pPeerHTCap->ShortGI20Mhz == 1) ?
548	true : false) : false);	549	true : false) : false);
549	pHTInfo->bCurShortGI40MHz = ((pHTInfo->bRegShortGI40MHz) ?	550	ht_info->bCurShortGI40MHz = ((ht_info->bRegShortGI40MHz) ?
550	((pPeerHTCap->ShortGI40Mhz == 1) ?	551	((pPeerHTCap->ShortGI40Mhz == 1) ?
551	true : false) : false);	552	true : false) : false);
552		553
553	pHTInfo->bCurSuppCCK = ((pHTInfo->bRegSuppCCK) ?	554	ht_info->bCurSuppCCK = ((ht_info->bRegSuppCCK) ?
554	((pPeerHTCap->DssCCk == 1) ? true :	555	((pPeerHTCap->DssCCk == 1) ? true :
555	false) : false);	556	false) : false);
556		557
557	pHTInfo->bCurrent_AMSDU_Support = pHTInfo->bAMSDU_Support;	558	ht_info->bCurrent_AMSDU_Support = ht_info->bAMSDU_Support;
558		559
559	nMaxAMSDUSize = (pPeerHTCap->MaxAMSDUSize == 0) ? 3839 : 7935;	560	nMaxAMSDUSize = (pPeerHTCap->MaxAMSDUSize == 0) ? 3839 : 7935;
560		561
561	if (pHTInfo->nAMSDU_MaxSize > nMaxAMSDUSize)	562	if (ht_info->nAMSDU_MaxSize > nMaxAMSDUSize)
562	pHTInfo->nCurrent_AMSDU_MaxSize = nMaxAMSDUSize;	563	ht_info->nCurrent_AMSDU_MaxSize = nMaxAMSDUSize;
563	else	564	else
564	pHTInfo->nCurrent_AMSDU_MaxSize = pHTInfo->nAMSDU_MaxSize;	565	ht_info->nCurrent_AMSDU_MaxSize = ht_info->nAMSDU_MaxSize;
565		566
566	pHTInfo->bCurrentAMPDUEnable = pHTInfo->bAMPDUEnable;	567	ht_info->bCurrentAMPDUEnable = ht_info->bAMPDUEnable;
567	if (ieee->rtllib_ap_sec_type &&	568	if (ieee->rtllib_ap_sec_type &&
568	(ieee->rtllib_ap_sec_type(ieee) & (SEC_ALG_WEP \| SEC_ALG_TKIP))) {	569	(ieee->rtllib_ap_sec_type(ieee) & (SEC_ALG_WEP \| SEC_ALG_TKIP))) {
569	if ((pHTInfo->IOTPeer == HT_IOT_PEER_ATHEROS) \|\|	570	if ((ht_info->IOTPeer == HT_IOT_PEER_ATHEROS) \|\|
570	(pHTInfo->IOTPeer == HT_IOT_PEER_UNKNOWN))	571	(ht_info->IOTPeer == HT_IOT_PEER_UNKNOWN))
571	pHTInfo->bCurrentAMPDUEnable = false;	572	ht_info->bCurrentAMPDUEnable = false;
572	}	573	}
573		574
574	if (!pHTInfo->reg_rt2rt_aggregation) {	575	if (!ht_info->reg_rt2rt_aggregation) {
575	if (pHTInfo->AMPDU_Factor > pPeerHTCap->MaxRxAMPDUFactor)	576	if (ht_info->AMPDU_Factor > pPeerHTCap->MaxRxAMPDUFactor)
576	pHTInfo->CurrentAMPDUFactor =	577	ht_info->CurrentAMPDUFactor =
577	pPeerHTCap->MaxRxAMPDUFactor;	578	pPeerHTCap->MaxRxAMPDUFactor;
578	else	579	else
579	pHTInfo->CurrentAMPDUFactor = pHTInfo->AMPDU_Factor;	580	ht_info->CurrentAMPDUFactor = ht_info->AMPDU_Factor;
580		581
581	} else {	582	} else {
582	if (ieee->current_network.bssht.bd_rt2rt_aggregation) {	583	if (ieee->current_network.bssht.bd_rt2rt_aggregation) {
583	if (ieee->pairwise_key_type != KEY_TYPE_NA)	584	if (ieee->pairwise_key_type != KEY_TYPE_NA)
584	pHTInfo->CurrentAMPDUFactor =	585	ht_info->CurrentAMPDUFactor =
585	pPeerHTCap->MaxRxAMPDUFactor;	586	pPeerHTCap->MaxRxAMPDUFactor;
586	else	587	else
587	pHTInfo->CurrentAMPDUFactor = HT_AGG_SIZE_64K;	588	ht_info->CurrentAMPDUFactor = HT_AGG_SIZE_64K;
588	} else {	589	} else {
589	if (pPeerHTCap->MaxRxAMPDUFactor < HT_AGG_SIZE_32K)	590	ht_info->CurrentAMPDUFactor = min_t(u32, pPeerHTCap->MaxRxAMPDUFactor,
590	pHTInfo->CurrentAMPDUFactor =	591	HT_AGG_SIZE_32K);
591	pPeerHTCap->MaxRxAMPDUFactor;
592	else
593	pHTInfo->CurrentAMPDUFactor = HT_AGG_SIZE_32K;
594	}	592	}
595	}	593	}
596	if (pHTInfo->MPDU_Density > pPeerHTCap->MPDUDensity)	594	ht_info->current_mpdu_density = max_t(u8, ht_info->MPDU_Density,
597	pHTInfo->current_mpdu_density = pHTInfo->MPDU_Density;	595	pPeerHTCap->MPDUDensity);
598	else	596	if (ht_info->iot_action & HT_IOT_ACT_TX_USE_AMSDU_8K) {
599	pHTInfo->current_mpdu_density = pPeerHTCap->MPDUDensity;	597	ht_info->bCurrentAMPDUEnable = false;
600	if (pHTInfo->iot_action & HT_IOT_ACT_TX_USE_AMSDU_8K) {	598	ht_info->ForcedAMSDUMode = HT_AGG_FORCE_ENABLE;
601	pHTInfo->bCurrentAMPDUEnable = false;
602	pHTInfo->ForcedAMSDUMode = HT_AGG_FORCE_ENABLE;
603	}	599	}
604	pHTInfo->cur_rx_reorder_enable = pHTInfo->reg_rx_reorder_enable;	600	ht_info->cur_rx_reorder_enable = ht_info->reg_rx_reorder_enable;
605		601
606	if (pPeerHTCap->MCS[0] == 0)	602	if (pPeerHTCap->MCS[0] == 0)
607	pPeerHTCap->MCS[0] = 0xff;	603	pPeerHTCap->MCS[0] = 0xff;
608		604
609	HTIOTActDetermineRaFunc(ieee, ((pPeerHTCap->MCS[1]) != 0));	605	HTIOTActDetermineRaFunc(ieee, ((pPeerHTCap->MCS[1]) != 0));
610		606
611	HTFilterMCSRate(ieee, pPeerHTCap->MCS, ieee->dot11HTOperationalRateSet);	607	HTFilterMCSRate(ieee, pPeerHTCap->MCS, ieee->dot11ht_oper_rate_set);
612		608
613	pHTInfo->peer_mimo_ps = pPeerHTCap->MimoPwrSave;	609	ht_info->peer_mimo_ps = pPeerHTCap->MimoPwrSave;
614	if (pHTInfo->peer_mimo_ps == MIMO_PS_STATIC)	610	if (ht_info->peer_mimo_ps == MIMO_PS_STATIC)
615	pMcsFilter = MCS_FILTER_1SS;	611	pMcsFilter = MCS_FILTER_1SS;
616	else	612	else
617	pMcsFilter = MCS_FILTER_ALL;	613	pMcsFilter = MCS_FILTER_ALL;
618	ieee->HTHighestOperaRate = HTGetHighestMCSRate(ieee,	614	ieee->HTHighestOperaRate = HTGetHighestMCSRate(ieee,
619	ieee->dot11HTOperationalRateSet, pMcsFilter);	615	ieee->dot11ht_oper_rate_set,
		616	pMcsFilter);
620	ieee->HTCurrentOperaRate = ieee->HTHighestOperaRate;	617	ieee->HTCurrentOperaRate = ieee->HTHighestOperaRate;
621		618
622	pHTInfo->current_op_mode = pPeerHTInfo->OptMode;	619	ht_info->current_op_mode = pPeerHTInfo->OptMode;
623	}	620	}
624		621
625	void HTInitializeHTInfo(struct rtllib_device *ieee)	622	void HTInitializeHTInfo(struct rtllib_device *ieee)
626	{	623	{
627	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	624	struct rt_hi_throughput *ht_info = ieee->ht_info;
628		625
629	pHTInfo->bCurrentHTSupport = false;	626	ht_info->bCurrentHTSupport = false;
630		627
631	pHTInfo->bCurBW40MHz = false;	628	ht_info->bCurBW40MHz = false;
632	pHTInfo->cur_tx_bw40mhz = false;	629	ht_info->cur_tx_bw40mhz = false;
633		630
634	pHTInfo->bCurShortGI20MHz = false;	631	ht_info->bCurShortGI20MHz = false;
635	pHTInfo->bCurShortGI40MHz = false;	632	ht_info->bCurShortGI40MHz = false;
636	pHTInfo->forced_short_gi = false;	633	ht_info->forced_short_gi = false;
637		634
638	pHTInfo->bCurSuppCCK = true;	635	ht_info->bCurSuppCCK = true;
639		636
640	pHTInfo->bCurrent_AMSDU_Support = false;	637	ht_info->bCurrent_AMSDU_Support = false;
641	pHTInfo->nCurrent_AMSDU_MaxSize = pHTInfo->nAMSDU_MaxSize;	638	ht_info->nCurrent_AMSDU_MaxSize = ht_info->nAMSDU_MaxSize;
642	pHTInfo->current_mpdu_density = pHTInfo->MPDU_Density;	639	ht_info->current_mpdu_density = ht_info->MPDU_Density;
643	pHTInfo->CurrentAMPDUFactor = pHTInfo->AMPDU_Factor;	640	ht_info->CurrentAMPDUFactor = ht_info->AMPDU_Factor;
644		641
645	memset((void *)(&(pHTInfo->SelfHTCap)), 0,	642	memset((void *)(&ht_info->SelfHTCap), 0,
646	sizeof(pHTInfo->SelfHTCap));	643	sizeof(ht_info->SelfHTCap));
647	memset((void *)(&(pHTInfo->SelfHTInfo)), 0,	644	memset((void *)(&ht_info->SelfHTInfo), 0,
648	sizeof(pHTInfo->SelfHTInfo));	645	sizeof(ht_info->SelfHTInfo));
649	memset((void *)(&(pHTInfo->PeerHTCapBuf)), 0,	646	memset((void *)(&ht_info->PeerHTCapBuf), 0,
650	sizeof(pHTInfo->PeerHTCapBuf));	647	sizeof(ht_info->PeerHTCapBuf));
651	memset((void *)(&(pHTInfo->PeerHTInfoBuf)), 0,	648	memset((void *)(&ht_info->PeerHTInfoBuf), 0,
652	sizeof(pHTInfo->PeerHTInfoBuf));	649	sizeof(ht_info->PeerHTInfoBuf));
653		650
654	pHTInfo->sw_bw_in_progress = false;	651	ht_info->sw_bw_in_progress = false;
655		652
656	pHTInfo->ePeerHTSpecVer = HT_SPEC_VER_IEEE;	653	ht_info->ePeerHTSpecVer = HT_SPEC_VER_IEEE;
657		654
658	pHTInfo->current_rt2rt_aggregation = false;	655	ht_info->current_rt2rt_aggregation = false;
659	pHTInfo->current_rt2rt_long_slot_time = false;	656	ht_info->current_rt2rt_long_slot_time = false;
660	pHTInfo->RT2RT_HT_Mode = (enum rt_ht_capability)0;	657	ht_info->RT2RT_HT_Mode = (enum rt_ht_capability)0;
661		658
662	pHTInfo->IOTPeer = 0;	659	ht_info->IOTPeer = 0;
663	pHTInfo->iot_action = 0;	660	ht_info->iot_action = 0;
664	pHTInfo->iot_ra_func = 0;	661	ht_info->iot_ra_func = 0;
665		662
666	{	663	{
667	u8 *RegHTSuppRateSets = &(ieee->RegHTSuppRateSet[0]);	664	u8 *RegHTSuppRateSets = &ieee->reg_ht_supp_rate_set[0];
668		665
669	RegHTSuppRateSets[0] = 0xFF;	666	RegHTSuppRateSets[0] = 0xFF;
670	RegHTSuppRateSets[1] = 0xFF;	667	RegHTSuppRateSets[1] = 0xFF;
@@ -690,130 +687,130 @@ void HTInitializeBssDesc(struct bss_ht *pBssHT) · 19 unmodified lines
690	void HTResetSelfAndSavePeerSetting(struct rtllib_device *ieee,	687	void HTResetSelfAndSavePeerSetting(struct rtllib_device *ieee,
691	struct rtllib_network *pNetwork)	688	struct rtllib_network *pNetwork)
692	{	689	{
693	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	690	struct rt_hi_throughput *ht_info = ieee->ht_info;
694	u8 bIOTAction = 0;	691	u8 bIOTAction = 0;
695		692
696	/* unmark bEnableHT flag here is the same reason why unmarked in	693	/* unmark enable_ht flag here is the same reason why unmarked in
697	* function rtllib_softmac_new_net. WB 2008.09.10	694	* function rtllib_softmac_new_net. WB 2008.09.10
698	*/	695	*/
699	if (pNetwork->bssht.bd_support_ht) {	696	if (pNetwork->bssht.bd_support_ht) {
700	pHTInfo->bCurrentHTSupport = true;	697	ht_info->bCurrentHTSupport = true;
701	pHTInfo->ePeerHTSpecVer = pNetwork->bssht.bd_ht_spec_ver;	698	ht_info->ePeerHTSpecVer = pNetwork->bssht.bd_ht_spec_ver;
702		699
703	if (pNetwork->bssht.bd_ht_cap_len > 0 &&	700	if (pNetwork->bssht.bd_ht_cap_len > 0 &&
704	pNetwork->bssht.bd_ht_cap_len <= sizeof(pHTInfo->PeerHTCapBuf))	701	pNetwork->bssht.bd_ht_cap_len <= sizeof(ht_info->PeerHTCapBuf))
705	memcpy(pHTInfo->PeerHTCapBuf,	702	memcpy(ht_info->PeerHTCapBuf,
706	pNetwork->bssht.bd_ht_cap_buf,	703	pNetwork->bssht.bd_ht_cap_buf,
707	pNetwork->bssht.bd_ht_cap_len);	704	pNetwork->bssht.bd_ht_cap_len);
708		705
709	if (pNetwork->bssht.bd_ht_info_len > 0 &&	706	if (pNetwork->bssht.bd_ht_info_len > 0 &&
710	pNetwork->bssht.bd_ht_info_len <=	707	pNetwork->bssht.bd_ht_info_len <=
711	sizeof(pHTInfo->PeerHTInfoBuf))	708	sizeof(ht_info->PeerHTInfoBuf))
712	memcpy(pHTInfo->PeerHTInfoBuf,	709	memcpy(ht_info->PeerHTInfoBuf,
713	pNetwork->bssht.bd_ht_info_buf,	710	pNetwork->bssht.bd_ht_info_buf,
714	pNetwork->bssht.bd_ht_info_len);	711	pNetwork->bssht.bd_ht_info_len);
715		712
716	if (pHTInfo->reg_rt2rt_aggregation) {	713	if (ht_info->reg_rt2rt_aggregation) {
717	pHTInfo->current_rt2rt_aggregation =	714	ht_info->current_rt2rt_aggregation =
718	pNetwork->bssht.bd_rt2rt_aggregation;	715	pNetwork->bssht.bd_rt2rt_aggregation;
719	pHTInfo->current_rt2rt_long_slot_time =	716	ht_info->current_rt2rt_long_slot_time =
720	pNetwork->bssht.bd_rt2rt_long_slot_time;	717	pNetwork->bssht.bd_rt2rt_long_slot_time;
721	pHTInfo->RT2RT_HT_Mode = pNetwork->bssht.rt2rt_ht_mode;	718	ht_info->RT2RT_HT_Mode = pNetwork->bssht.rt2rt_ht_mode;
722	} else {	719	} else {
723	pHTInfo->current_rt2rt_aggregation = false;	720	ht_info->current_rt2rt_aggregation = false;
724	pHTInfo->current_rt2rt_long_slot_time = false;	721	ht_info->current_rt2rt_long_slot_time = false;
725	pHTInfo->RT2RT_HT_Mode = (enum rt_ht_capability)0;	722	ht_info->RT2RT_HT_Mode = (enum rt_ht_capability)0;
726	}	723	}
727		724
728	HTIOTPeerDetermine(ieee);	725	HTIOTPeerDetermine(ieee);
729		726
730	pHTInfo->iot_action = 0;	727	ht_info->iot_action = 0;
731	bIOTAction = HTIOTActIsDisableMCS14(ieee, pNetwork->bssid);	728	bIOTAction = HTIOTActIsDisableMCS14(ieee, pNetwork->bssid);
732	if (bIOTAction)	729	if (bIOTAction)
733	pHTInfo->iot_action \|= HT_IOT_ACT_DISABLE_MCS14;	730	ht_info->iot_action \|= HT_IOT_ACT_DISABLE_MCS14;
734		731
735	bIOTAction = HTIOTActIsDisableMCS15(ieee);	732	bIOTAction = HTIOTActIsDisableMCS15(ieee);
736	if (bIOTAction)	733	if (bIOTAction)
737	pHTInfo->iot_action \|= HT_IOT_ACT_DISABLE_MCS15;	734	ht_info->iot_action \|= HT_IOT_ACT_DISABLE_MCS15;
738		735
739	bIOTAction = HTIOTActIsDisableMCSTwoSpatialStream(ieee);	736	bIOTAction = HTIOTActIsDisableMCSTwoSpatialStream(ieee);
740	if (bIOTAction)	737	if (bIOTAction)
741	pHTInfo->iot_action \|= HT_IOT_ACT_DISABLE_ALL_2SS;	738	ht_info->iot_action \|= HT_IOT_ACT_DISABLE_ALL_2SS;
742		739
743	bIOTAction = HTIOTActIsDisableEDCATurbo(ieee, pNetwork->bssid);	740	bIOTAction = HTIOTActIsDisableEDCATurbo(ieee, pNetwork->bssid);
744	if (bIOTAction)	741	if (bIOTAction)
745	pHTInfo->iot_action \|= HT_IOT_ACT_DISABLE_EDCA_TURBO;	742	ht_info->iot_action \|= HT_IOT_ACT_DISABLE_EDCA_TURBO;
746		743
747	bIOTAction = HTIOTActIsMgntUseCCK6M(ieee, pNetwork);	744	bIOTAction = HTIOTActIsMgntUseCCK6M(ieee, pNetwork);
748	if (bIOTAction)	745	if (bIOTAction)
749	pHTInfo->iot_action \|= HT_IOT_ACT_MGNT_USE_CCK_6M;	746	ht_info->iot_action \|= HT_IOT_ACT_MGNT_USE_CCK_6M;
750	bIOTAction = HTIOTActIsCCDFsync(ieee);	747	bIOTAction = HTIOTActIsCCDFsync(ieee);
751	if (bIOTAction)	748	if (bIOTAction)
752	pHTInfo->iot_action \|= HT_IOT_ACT_CDD_FSYNC;	749	ht_info->iot_action \|= HT_IOT_ACT_CDD_FSYNC;
753	} else {	750	} else {
754	pHTInfo->bCurrentHTSupport = false;	751	ht_info->bCurrentHTSupport = false;
755	pHTInfo->current_rt2rt_aggregation = false;	752	ht_info->current_rt2rt_aggregation = false;
756	pHTInfo->current_rt2rt_long_slot_time = false;	753	ht_info->current_rt2rt_long_slot_time = false;
757	pHTInfo->RT2RT_HT_Mode = (enum rt_ht_capability)0;	754	ht_info->RT2RT_HT_Mode = (enum rt_ht_capability)0;
758		755
759	pHTInfo->iot_action = 0;	756	ht_info->iot_action = 0;
760	pHTInfo->iot_ra_func = 0;	757	ht_info->iot_ra_func = 0;
761	}	758	}
762	}	759	}
763		760
764	void HT_update_self_and_peer_setting(struct rtllib_device *ieee,	761	void HT_update_self_and_peer_setting(struct rtllib_device *ieee,
765	struct rtllib_network *pNetwork)	762	struct rtllib_network *pNetwork)
766	{	763	{
767	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	764	struct rt_hi_throughput *ht_info = ieee->ht_info;
768	struct ht_info_ele *pPeerHTInfo =	765	struct ht_info_ele *pPeerHTInfo =
769	(struct ht_info_ele *)pNetwork->bssht.bd_ht_info_buf;	766	(struct ht_info_ele *)pNetwork->bssht.bd_ht_info_buf;
770		767
771	if (pHTInfo->bCurrentHTSupport) {	768	if (ht_info->bCurrentHTSupport) {
772	if (pNetwork->bssht.bd_ht_info_len != 0)	769	if (pNetwork->bssht.bd_ht_info_len != 0)
773	pHTInfo->current_op_mode = pPeerHTInfo->OptMode;	770	ht_info->current_op_mode = pPeerHTInfo->OptMode;
774	}	771	}
775	}	772	}
776	EXPORT_SYMBOL(HT_update_self_and_peer_setting);	773	EXPORT_SYMBOL(HT_update_self_and_peer_setting);
777		774
778	void HTUseDefaultSetting(struct rtllib_device *ieee)	775	void HTUseDefaultSetting(struct rtllib_device *ieee)
779	{	776	{
780	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	777	struct rt_hi_throughput *ht_info = ieee->ht_info;
781		778
782	if (pHTInfo->bEnableHT) {	779	if (ht_info->enable_ht) {
783	pHTInfo->bCurrentHTSupport = true;	780	ht_info->bCurrentHTSupport = true;
784	pHTInfo->bCurSuppCCK = pHTInfo->bRegSuppCCK;	781	ht_info->bCurSuppCCK = ht_info->bRegSuppCCK;
785		782
786	pHTInfo->bCurBW40MHz = pHTInfo->bRegBW40MHz;	783	ht_info->bCurBW40MHz = ht_info->bRegBW40MHz;
787	pHTInfo->bCurShortGI20MHz = pHTInfo->bRegShortGI20MHz;	784	ht_info->bCurShortGI20MHz = ht_info->bRegShortGI20MHz;
788		785
789	pHTInfo->bCurShortGI40MHz = pHTInfo->bRegShortGI40MHz;	786	ht_info->bCurShortGI40MHz = ht_info->bRegShortGI40MHz;
790		787
791	if (ieee->iw_mode == IW_MODE_ADHOC)	788	if (ieee->iw_mode == IW_MODE_ADHOC)
792	ieee->current_network.qos_data.active =	789	ieee->current_network.qos_data.active =
793	ieee->current_network.qos_data.supported;	790	ieee->current_network.qos_data.supported;
794	pHTInfo->bCurrent_AMSDU_Support = pHTInfo->bAMSDU_Support;	791	ht_info->bCurrent_AMSDU_Support = ht_info->bAMSDU_Support;
795	pHTInfo->nCurrent_AMSDU_MaxSize = pHTInfo->nAMSDU_MaxSize;	792	ht_info->nCurrent_AMSDU_MaxSize = ht_info->nAMSDU_MaxSize;
796		793
797	pHTInfo->bCurrentAMPDUEnable = pHTInfo->bAMPDUEnable;	794	ht_info->bCurrentAMPDUEnable = ht_info->bAMPDUEnable;
798	pHTInfo->CurrentAMPDUFactor = pHTInfo->AMPDU_Factor;	795	ht_info->CurrentAMPDUFactor = ht_info->AMPDU_Factor;
799		796
800	pHTInfo->current_mpdu_density = pHTInfo->current_mpdu_density;	797	ht_info->current_mpdu_density = ht_info->current_mpdu_density;
801		798
802	HTFilterMCSRate(ieee, ieee->Regdot11TxHTOperationalRateSet,	799	HTFilterMCSRate(ieee, ieee->reg_dot11tx_ht_oper_rate_set,
803	ieee->dot11HTOperationalRateSet);	800	ieee->dot11ht_oper_rate_set);
804	ieee->HTHighestOperaRate = HTGetHighestMCSRate(ieee,	801	ieee->HTHighestOperaRate = HTGetHighestMCSRate(ieee,
805	ieee->dot11HTOperationalRateSet,	802	ieee->dot11ht_oper_rate_set,
806	MCS_FILTER_ALL);	803	MCS_FILTER_ALL);
807	ieee->HTCurrentOperaRate = ieee->HTHighestOperaRate;	804	ieee->HTCurrentOperaRate = ieee->HTHighestOperaRate;
808		805
809	} else {	806	} else {
810	pHTInfo->bCurrentHTSupport = false;	807	ht_info->bCurrentHTSupport = false;
811	}	808	}
812	}	809	}
813		810
814	u8 HTCCheck(struct rtllib_device ieee, u8 pFrame)	811	u8 HTCCheck(struct rtllib_device ieee, u8 pFrame)
815	{	812	{
816	if (ieee->pHTInfo->bCurrentHTSupport) {	813	if (ieee->ht_info->bCurrentHTSupport) {
817	if ((IsQoSDataFrame(pFrame) && Frame_Order(pFrame)) == 1) {	814	if ((IsQoSDataFrame(pFrame) && Frame_Order(pFrame)) == 1) {
818	netdev_dbg(ieee->dev, "HT CONTROL FILED EXIST!!\n");	815	netdev_dbg(ieee->dev, "HT CONTROL FILED EXIST!!\n");
819	return true;	816	return true;
@@ -824,13 +821,13 @@ u8 HTCCheck(struct rtllib_device ieee, u8 pFrame) · 4 unmodified lines
824		821
825	static void HTSetConnectBwModeCallback(struct rtllib_device *ieee)	822	static void HTSetConnectBwModeCallback(struct rtllib_device *ieee)
826	{	823	{
827	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	824	struct rt_hi_throughput *ht_info = ieee->ht_info;
828		825
829	if (pHTInfo->bCurBW40MHz) {	826	if (ht_info->bCurBW40MHz) {
830	if (pHTInfo->CurSTAExtChnlOffset == HT_EXTCHNL_OFFSET_UPPER)	827	if (ht_info->CurSTAExtChnlOffset == HT_EXTCHNL_OFFSET_UPPER)
831	ieee->set_chan(ieee->dev,	828	ieee->set_chan(ieee->dev,
832	ieee->current_network.channel + 2);	829	ieee->current_network.channel + 2);
833	else if (pHTInfo->CurSTAExtChnlOffset ==	830	else if (ht_info->CurSTAExtChnlOffset ==
834	HT_EXTCHNL_OFFSET_LOWER)	831	HT_EXTCHNL_OFFSET_LOWER)
835	ieee->set_chan(ieee->dev,	832	ieee->set_chan(ieee->dev,
836	ieee->current_network.channel - 2);	833	ieee->current_network.channel - 2);
@@ -839,29 +836,29 @@ static void HTSetConnectBwModeCallback(struct rtllib_device *ieee) · 2 unmodified lines
839	ieee->current_network.channel);	836	ieee->current_network.channel);
840		837
841	ieee->SetBWModeHandler(ieee->dev, HT_CHANNEL_WIDTH_20_40,	838	ieee->SetBWModeHandler(ieee->dev, HT_CHANNEL_WIDTH_20_40,
842	pHTInfo->CurSTAExtChnlOffset);	839	ht_info->CurSTAExtChnlOffset);
843	} else {	840	} else {
844	ieee->set_chan(ieee->dev, ieee->current_network.channel);	841	ieee->set_chan(ieee->dev, ieee->current_network.channel);
845	ieee->SetBWModeHandler(ieee->dev, HT_CHANNEL_WIDTH_20,	842	ieee->SetBWModeHandler(ieee->dev, HT_CHANNEL_WIDTH_20,
846	HT_EXTCHNL_OFFSET_NO_EXT);	843	HT_EXTCHNL_OFFSET_NO_EXT);
847	}	844	}
848		845
849	pHTInfo->sw_bw_in_progress = false;	846	ht_info->sw_bw_in_progress = false;
850	}	847	}
851		848
852	void HTSetConnectBwMode(struct rtllib_device *ieee,	849	void HTSetConnectBwMode(struct rtllib_device *ieee,
853	enum ht_channel_width bandwidth,	850	enum ht_channel_width bandwidth,
854	enum ht_extchnl_offset Offset)	851	enum ht_extchnl_offset Offset)
855	{	852	{
856	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	853	struct rt_hi_throughput *ht_info = ieee->ht_info;
857		854
858	if (!pHTInfo->bRegBW40MHz)	855	if (!ht_info->bRegBW40MHz)
859	return;	856	return;
860		857
861	if (ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev))	858	if (ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev))
862	bandwidth = HT_CHANNEL_WIDTH_20;	859	bandwidth = HT_CHANNEL_WIDTH_20;
863		860
864	if (pHTInfo->sw_bw_in_progress) {	861	if (ht_info->sw_bw_in_progress) {
865	pr_info("%s: sw_bw_in_progress!!\n", __func__);	862	pr_info("%s: sw_bw_in_progress!!\n", __func__);
866	return;	863	return;
867	}	864	}
@@ -871,21 +868,21 @@ void HTSetConnectBwMode(struct rtllib_device *ieee, · 3 unmodified lines
871	Offset = HT_EXTCHNL_OFFSET_NO_EXT;	868	Offset = HT_EXTCHNL_OFFSET_NO_EXT;
872	if (Offset == HT_EXTCHNL_OFFSET_UPPER \|\|	869	if (Offset == HT_EXTCHNL_OFFSET_UPPER \|\|
873	Offset == HT_EXTCHNL_OFFSET_LOWER) {	870	Offset == HT_EXTCHNL_OFFSET_LOWER) {
874	pHTInfo->bCurBW40MHz = true;	871	ht_info->bCurBW40MHz = true;
875	pHTInfo->CurSTAExtChnlOffset = Offset;	872	ht_info->CurSTAExtChnlOffset = Offset;
876	} else {	873	} else {
877	pHTInfo->bCurBW40MHz = false;	874	ht_info->bCurBW40MHz = false;
878	pHTInfo->CurSTAExtChnlOffset = HT_EXTCHNL_OFFSET_NO_EXT;	875	ht_info->CurSTAExtChnlOffset = HT_EXTCHNL_OFFSET_NO_EXT;
879	}	876	}
880	} else {	877	} else {
881	pHTInfo->bCurBW40MHz = false;	878	ht_info->bCurBW40MHz = false;
882	pHTInfo->CurSTAExtChnlOffset = HT_EXTCHNL_OFFSET_NO_EXT;	879	ht_info->CurSTAExtChnlOffset = HT_EXTCHNL_OFFSET_NO_EXT;
883	}	880	}
884		881
885	netdev_dbg(ieee->dev, "%s():pHTInfo->bCurBW40MHz:%x\n", __func__,	882	netdev_dbg(ieee->dev, "%s():ht_info->bCurBW40MHz:%x\n", __func__,
886	pHTInfo->bCurBW40MHz);	883	ht_info->bCurBW40MHz);
887		884
888	pHTInfo->sw_bw_in_progress = true;	885	ht_info->sw_bw_in_progress = true;
889		886
890	HTSetConnectBwModeCallback(ieee);	887	HTSetConnectBwModeCallback(ieee);
891	}	888	}

drivers/staging/rtl8192e/rtl819x_Qos.h+0−7

@@ -97,13 +97,6 @@ enum direction_value { · 96 unmodified lines
97	DIR_BI_DIR = 3,	97	DIR_BI_DIR = 3,
98	};	98	};
99		99
100	enum acm_method {
101	eAcmWay0_SwAndHw = 0,
102	eAcmWay1_HW = 1,
103	eAcmWay2_SW = 2,
104	};
105
106
107	struct acm {	100	struct acm {
108	u64 UsedTime;	101	u64 UsedTime;
109	u64 MediumTime;	102	u64 MediumTime;

drivers/staging/rtl8192e/rtl819x_TSProc.c+1−1

@@ -83,7 +83,7 @@ static void RxPktPendingTimeout(struct timer_list *t) · 82 unmodified lines
83	if (bPktInBuf && (pRxTs->rx_timeout_indicate_seq == 0xffff)) {	83	if (bPktInBuf && (pRxTs->rx_timeout_indicate_seq == 0xffff)) {
84	pRxTs->rx_timeout_indicate_seq = pRxTs->rx_indicate_seq;	84	pRxTs->rx_timeout_indicate_seq = pRxTs->rx_indicate_seq;
85	mod_timer(&pRxTs->rx_pkt_pending_timer, jiffies +	85	mod_timer(&pRxTs->rx_pkt_pending_timer, jiffies +
86	msecs_to_jiffies(ieee->pHTInfo->rx_reorder_pending_time)	86	msecs_to_jiffies(ieee->ht_info->rx_reorder_pending_time)
87	);	87	);
88	}	88	}
89	spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags);	89	spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags);

drivers/staging/rtl8192e/rtllib.h+22−29

 #define SUPPORT_CKIP_MIC			0x08
 #define SUPPORT_CKIP_PK			0x10
 #define	RT_RF_OFF_LEVL_HALT_NIC		BIT3
-#define	RT_IN_PS_LEVEL(pPSC, _PS_FLAG)		\
+#define	RT_IN_PS_LEVEL(psc, _PS_FLAG)		\
-	((pPSC->CurPsLevel & _PS_FLAG) ? true : false)
+	((psc->CurPsLevel & _PS_FLAG) ? true : false)
-#define	RT_CLEAR_PS_LEVEL(pPSC, _PS_FLAG)	\
+#define	RT_CLEAR_PS_LEVEL(psc, _PS_FLAG)	\
-	(pPSC->CurPsLevel &= (~(_PS_FLAG)))
+	(psc->CurPsLevel &= (~(_PS_FLAG)))
-#define	RT_SET_PS_LEVEL(pPSC, _PS_FLAG)	(pPSC->CurPsLevel |= _PS_FLAG)
+#define	RT_SET_PS_LEVEL(psc, _PS_FLAG)	(psc->CurPsLevel |= _PS_FLAG)
 /* defined for skb cb field */
 /* At most 28 byte */
 	u8 bFirstSeg:1;
 	u8 bLastSeg:1;
 	u8 bEncrypt:1;
-	u8 bTxDisableRateFallBack:1;
+	u8 tx_dis_rate_fallback:1;
-	u8 bTxUseDriverAssingedRate:1;
+	u8 tx_use_drv_assinged_rate:1;
 	u8 bHwSec:1;
 	u8 nStuckCount;
 };
 struct rt_pwr_save_ctrl {
-	bool				bInactivePs;
-	bool				bIPSModeBackup;
 	bool				bSwRfProcessing;
 	enum rt_rf_power_state eInactivePowerState;
 	enum ips_callback_function ReturnPoint;
 	bool				bLeisurePs;
 	u8				LpsIdleCount;
-	u8				RegMaxLPSAwakeIntvl;
+	u8				reg_max_lps_awake_intvl;
 	u8				LPSAwakeIntvl;
 	u32				CurPsLevel;
 	u32				RegRfPsLevel;
-	bool				bFwCtrlLPS;
 };
 #define RT_RF_CHANGE_SOURCE u32
 };
 struct rt_intel_promisc_mode {
-	bool bPromiscuousOn;
+	bool promiscuous_on;
-	bool bFilterSourceStationFrame;
+	bool fltr_src_sta_frame;
 };
 	RT_RF_CHANGE_SOURCE rf_off_reason;
 	bool is_set_key;
 	bool wx_set_enc;
-	struct rt_hi_throughput *pHTInfo;
+	struct rt_hi_throughput *ht_info;
 	spinlock_t reorder_spinlock;
-	u8	Regdot11HTOperationalRateSet[16];
+	u8	reg_dot11ht_oper_rate_set[16];
-	u8	Regdot11TxHTOperationalRateSet[16];
+	u8	reg_dot11tx_ht_oper_rate_set[16];
-	u8	dot11HTOperationalRateSet[16];
+	u8	dot11ht_oper_rate_set[16];
-	u8	RegHTSuppRateSet[16];
+	u8	reg_ht_supp_rate_set[16];
 	u8	HTCurrentOperaRate;
 	u8	HTHighestOperaRate;
-	u8	bTxDisableRateFallBack;
+	u8	tx_dis_rate_fallback;
-	u8	bTxUseDriverAssingedRate;
+	u8	tx_use_drv_assinged_rate;
 	u8	bTxEnableFwCalcDur;
 	atomic_t	atm_swbw;
 	int scan_age;
 	int iw_mode; /* operating mode (IW_MODE_*) */
-	bool bNetPromiscuousMode;
+	bool net_promiscuous_md;
-	struct rt_intel_promisc_mode IntelPromiscuousModeInfo;
+	struct rt_intel_promisc_mode intel_promiscuous_md_info;
 	spinlock_t lock;
 	spinlock_t wpax_suitlist_lock;
 	int mgmt_queue_tail;
 	u8 AsocRetryCount;
 	struct sk_buff_head skb_waitQ[MAX_QUEUE_SIZE];
-	struct sk_buff_head  skb_aggQ[MAX_QUEUE_SIZE];
 	bool	bdynamic_txpower_enable;
 	struct bandwidth_autoswitch bandwidth_auto_switch;
 	bool FwRWRF;
-	struct rt_link_detect LinkDetectInfo;
+	struct rt_link_detect link_detect_info;
 	bool bIsAggregateFrame;
-	struct rt_pwr_save_ctrl PowerSaveControl;
+	struct rt_pwr_save_ctrl pwr_save_ctrl;
 	/* used if IEEE_SOFTMAC_TX_QUEUE is set */
 	struct tx_pending tx_pending;
 extern u8 MCS_FILTER_ALL[];
 extern u16 MCS_DATA_RATE[2][2][77];
 u8 HTCCheck(struct rtllib_device *ieee, u8 *pFrame);
-void HTResetIOTSetting(struct rt_hi_throughput *pHTInfo);
+void HTResetIOTSetting(struct rt_hi_throughput *ht_info);
 bool IsHTHalfNmodeAPs(struct rtllib_device *ieee);
 u16  TxCountToDataRate(struct rtllib_device *ieee, u8 nDataRate);
 int rtllib_rx_ADDBAReq(struct rtllib_device *ieee, struct sk_buff *skb);

drivers/staging/rtl8192e/rtllib_crypt_tkip.c+16−36

@@ -62,7 +62,7 @@ static void *rtllib_tkip_init(int key_idx) · 61 unmodified lines
62	return NULL;	62	return NULL;
63		63
64	priv = kzalloc(sizeof(*priv), GFP_ATOMIC);	64	priv = kzalloc(sizeof(*priv), GFP_ATOMIC);
65	if (priv == NULL)	65	if (!priv)
66	goto fail;	66	goto fail;
67	priv->key_idx = key_idx;	67	priv->key_idx = key_idx;
68		68
@@ -91,7 +91,6 @@ fail: · 22 unmodified lines
91	return NULL;	91	return NULL;
92	}	92	}
93		93
94
95	static void rtllib_tkip_deinit(void *priv)	94	static void rtllib_tkip_deinit(void *priv)
96	{	95	{
97	struct rtllib_tkip_data *_priv = priv;	96	struct rtllib_tkip_data *_priv = priv;
@@ -103,49 +102,41 @@ static void rtllib_tkip_deinit(void *priv) · 5 unmodified lines
103	kfree_sensitive(priv);	102	kfree_sensitive(priv);
104	}	103	}
105		104
106
107	static inline u16 RotR1(u16 val)	105	static inline u16 RotR1(u16 val)
108	{	106	{
109	return (val >> 1) \| (val << 15);	107	return (val >> 1) \| (val << 15);
110	}	108	}
111		109
112
113	static inline u8 Lo8(u16 val)	110	static inline u8 Lo8(u16 val)
114	{	111	{
115	return val & 0xff;	112	return val & 0xff;
116	}	113	}
117		114
118
119	static inline u8 Hi8(u16 val)	115	static inline u8 Hi8(u16 val)
120	{	116	{
121	return val >> 8;	117	return val >> 8;
122	}	118	}
123		119
124
125	static inline u16 Lo16(u32 val)	120	static inline u16 Lo16(u32 val)
126	{	121	{
127	return val & 0xffff;	122	return val & 0xffff;
128	}	123	}
129		124
130
131	static inline u16 Hi16(u32 val)	125	static inline u16 Hi16(u32 val)
132	{	126	{
133	return val >> 16;	127	return val >> 16;
134	}	128	}
135		129
136
137	static inline u16 Mk16(u8 hi, u8 lo)	130	static inline u16 Mk16(u8 hi, u8 lo)
138	{	131	{
139	return lo \| (hi << 8);	132	return lo \| (hi << 8);
140	}	133	}
141		134
142
143	static inline u16 Mk16_le(u16 *v)	135	static inline u16 Mk16_le(u16 *v)
144	{	136	{
145	return *v;	137	return *v;
146	}	138	}
147		139
148
149	static const u16 Sbox[256] = {	140	static const u16 Sbox[256] = {
150	0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,	141	0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,
151	0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,	142	0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,
@@ -181,17 +172,14 @@ static const u16 Sbox[256] = { · 29 unmodified lines
181	0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A,	172	0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A,
182	};	173	};
183		174
184
185	static inline u16 _S_(u16 v)	175	static inline u16 _S_(u16 v)
186	{	176	{
187	u16 t = Sbox[Hi8(v)];	177	u16 t = Sbox[Hi8(v)];
188	return Sbox[Lo8(v)] ^ ((t << 8) \| (t >> 8));	178	return Sbox[Lo8(v)] ^ ((t << 8) \| (t >> 8));
189	}	179	}
190		180
191
192	#define PHASE1_LOOP_COUNT 8	181	#define PHASE1_LOOP_COUNT 8
193		182
194
195	static void tkip_mixing_phase1(u16 TTAK, const u8 TK, const u8 *TA, u32 IV32)	183	static void tkip_mixing_phase1(u16 TTAK, const u8 TK, const u8 *TA, u32 IV32)
196	{	184	{
197	int i, j;	185	int i, j;
@@ -213,7 +201,6 @@ static void tkip_mixing_phase1(u16 TTAK, const u8 TK, const u8 *TA, u32 IV32) · 15 unmodified lines
213	}	201	}
214	}	202	}
215		203
216
217	static void tkip_mixing_phase2(u8 WEPSeed, const u8 TK, const u16 *TTAK,	204	static void tkip_mixing_phase2(u8 WEPSeed, const u8 TK, const u16 *TTAK,
218	u16 IV16)	205	u16 IV16)
219	{	206	{
@@ -263,7 +250,6 @@ static void tkip_mixing_phase2(u8 WEPSeed, const u8 TK, const u16 *TTAK, · 43 unmodified lines
263	#endif	250	#endif
264	}	251	}
265		252
266
267	static int rtllib_tkip_encrypt(struct sk_buff skb, int hdr_len, void priv)	253	static int rtllib_tkip_encrypt(struct sk_buff skb, int hdr_len, void priv)
268	{	254	{
269	struct rtllib_tkip_data *tkey = priv;	255	struct rtllib_tkip_data *tkey = priv;
@@ -285,14 +271,14 @@ static int rtllib_tkip_encrypt(struct sk_buff skb, int hdr_len, void priv) · 15 unmodified lines
285	if (!tcb_desc->bHwSec) {	271	if (!tcb_desc->bHwSec) {
286	if (!tkey->tx_phase1_done) {	272	if (!tkey->tx_phase1_done) {
287	tkip_mixing_phase1(tkey->tx_ttak, tkey->key, hdr->addr2,	273	tkip_mixing_phase1(tkey->tx_ttak, tkey->key, hdr->addr2,
288	tkey->tx_iv32);	274	tkey->tx_iv32);
289	tkey->tx_phase1_done = 1;	275	tkey->tx_phase1_done = 1;
290	}	276	}
291	tkip_mixing_phase2(rc4key, tkey->key, tkey->tx_ttak,	277	tkip_mixing_phase2(rc4key, tkey->key, tkey->tx_ttak,
292	tkey->tx_iv16);	278	tkey->tx_iv16);
293	} else	279	} else {
294	tkey->tx_phase1_done = 1;	280	tkey->tx_phase1_done = 1;
295		281	}
296		282
297	len = skb->len - hdr_len;	283	len = skb->len - hdr_len;
298	pos = skb_push(skb, 8);	284	pos = skb_push(skb, 8);
@@ -336,8 +322,6 @@ static int rtllib_tkip_encrypt(struct sk_buff skb, int hdr_len, void priv) · 37 unmodified lines
336	if (!tcb_desc->bHwSec)	322	if (!tcb_desc->bHwSec)
337	return ret;	323	return ret;
338	return 0;	324	return 0;
339
340
341	}	325	}
342		326
343	static int rtllib_tkip_decrypt(struct sk_buff skb, int hdr_len, void priv)	327	static int rtllib_tkip_decrypt(struct sk_buff skb, int hdr_len, void priv)
@@ -389,8 +373,8 @@ static int rtllib_tkip_decrypt(struct sk_buff skb, int hdr_len, void priv) · 45 unmodified lines
389		373
390	if (!tcb_desc->bHwSec \|\| (skb->cb[0] == 1)) {	374	if (!tcb_desc->bHwSec \|\| (skb->cb[0] == 1)) {
391	if ((iv32 < tkey->rx_iv32 \|\|	375	if ((iv32 < tkey->rx_iv32 \|\|
392	(iv32 == tkey->rx_iv32 && iv16 <= tkey->rx_iv16)) &&	376	(iv32 == tkey->rx_iv32 && iv16 <= tkey->rx_iv16)) &&
393	tkey->initialized) {	377	tkey->initialized) {
394	if (net_ratelimit()) {	378	if (net_ratelimit()) {
395	netdev_dbg(skb->dev,	379	netdev_dbg(skb->dev,
396	"Replay detected: STA= %pM previous TSC %08x%04x received TSC %08x%04x\n",	380	"Replay detected: STA= %pM previous TSC %08x%04x received TSC %08x%04x\n",
@@ -436,7 +420,6 @@ static int rtllib_tkip_decrypt(struct sk_buff skb, int hdr_len, void priv) · 39 unmodified lines
436	tkey->dot11RSNAStatsTKIPICVErrors++;	420	tkey->dot11RSNAStatsTKIPICVErrors++;
437	return -5;	421	return -5;
438	}	422	}
439
440	}	423	}
441		424
442	/* Update real counters only after Michael MIC verification has	425	/* Update real counters only after Michael MIC verification has
@@ -453,7 +436,6 @@ static int rtllib_tkip_decrypt(struct sk_buff skb, int hdr_len, void priv) · 10 unmodified lines
453	return keyidx;	436	return keyidx;
454	}	437	}
455		438
456
457	static int michael_mic(struct crypto_shash tfm_michael, u8 key, u8 *hdr,	439	static int michael_mic(struct crypto_shash tfm_michael, u8 key, u8 *hdr,
458	u8 data, size_t data_len, u8 mic)	440	u8 data, size_t data_len, u8 mic)
459	{	441	{
@@ -506,12 +488,15 @@ static void michael_mic_hdr(struct sk_buff skb, u8 hdr) · 46 unmodified lines
506	break;	488	break;
507	}	489	}
508		490
509	hdr[12] = 0; /* priority */	491	/* priority */
		492	hdr[12] = 0;
510		493
511	hdr[13] = hdr[14] = hdr[15] = 0; /* reserved */	494	/* reserved */
		495	hdr[13] = 0;
		496	hdr[14] = 0;
		497	hdr[15] = 0;
512	}	498	}
513		499
514
515	static int rtllib_michael_mic_add(struct sk_buff skb, int hdr_len, void priv)	500	static int rtllib_michael_mic_add(struct sk_buff skb, int hdr_len, void priv)
516	{	501	{
517	struct rtllib_tkip_data *tkey = priv;	502	struct rtllib_tkip_data *tkey = priv;
@@ -533,13 +518,12 @@ static int rtllib_michael_mic_add(struct sk_buff skb, int hdr_len, void priv) · 15 unmodified lines
533	tkey->tx_hdr[12] = *(skb->data + hdr_len - 2) & 0x07;	518	tkey->tx_hdr[12] = *(skb->data + hdr_len - 2) & 0x07;
534	pos = skb_put(skb, 8);	519	pos = skb_put(skb, 8);
535	if (michael_mic(tkey->tx_tfm_michael, &tkey->key[16], tkey->tx_hdr,	520	if (michael_mic(tkey->tx_tfm_michael, &tkey->key[16], tkey->tx_hdr,
536	skb->data + hdr_len, skb->len - 8 - hdr_len, pos))	521	skb->data + hdr_len, skb->len - 8 - hdr_len, pos))
537	return -1;	522	return -1;
538		523
539	return 0;	524	return 0;
540	}	525	}
541		526
542
543	static void rtllib_michael_mic_failure(struct net_device *dev,	527	static void rtllib_michael_mic_failure(struct net_device *dev,
544	struct rtllib_hdr_4addr *hdr,	528	struct rtllib_hdr_4addr *hdr,
545	int keyidx)	529	int keyidx)
@@ -609,7 +593,6 @@ static int rtllib_michael_mic_verify(struct sk_buff *skb, int keyidx, · 63 unmodified lines
609	return 0;	593	return 0;
610	}	594	}
611		595
612
613	static int rtllib_tkip_set_key(void key, int len, u8 seq, void *priv)	596	static int rtllib_tkip_set_key(void key, int len, u8 seq, void *priv)
614	{	597	{
615	struct rtllib_tkip_data *tkey = priv;	598	struct rtllib_tkip_data *tkey = priv;
@@ -632,15 +615,15 @@ static int rtllib_tkip_set_key(void key, int len, u8 seq, void *priv) · 16 unmodified lines
632	(seq[3] << 8) \| seq[2];	615	(seq[3] << 8) \| seq[2];
633	tkey->rx_iv16 = (seq[1] << 8) \| seq[0];	616	tkey->rx_iv16 = (seq[1] << 8) \| seq[0];
634	}	617	}
635	} else if (len == 0)	618	} else if (len == 0) {
636	tkey->key_set = 0;	619	tkey->key_set = 0;
637	else	620	} else {
638	return -1;	621	return -1;
		622	}
639		623
640	return 0;	624	return 0;
641	}	625	}
642		626
643
644	static int rtllib_tkip_get_key(void key, int len, u8 seq, void *priv)	627	static int rtllib_tkip_get_key(void key, int len, u8 seq, void *priv)
645	{	628	{
646	struct rtllib_tkip_data *tkey = priv;	629	struct rtllib_tkip_data *tkey = priv;
@@ -671,7 +654,6 @@ static int rtllib_tkip_get_key(void key, int len, u8 seq, void *priv) · 24 unmodified lines
671	return TKIP_KEY_LEN;	654	return TKIP_KEY_LEN;
672	}	655	}
673		656
674
675	static void rtllib_tkip_print_stats(struct seq_file m, void priv)	657	static void rtllib_tkip_print_stats(struct seq_file m, void priv)
676	{	658	{
677	struct rtllib_tkip_data *tkip = priv;	659	struct rtllib_tkip_data *tkip = priv;
@@ -713,13 +695,11 @@ static struct lib80211_crypto_ops rtllib_crypt_tkip = { · 35 unmodified lines
713	.owner = THIS_MODULE,	695	.owner = THIS_MODULE,
714	};	696	};
715		697
716
717	static int __init rtllib_crypto_tkip_init(void)	698	static int __init rtllib_crypto_tkip_init(void)
718	{	699	{
719	return lib80211_register_crypto_ops(&rtllib_crypt_tkip);	700	return lib80211_register_crypto_ops(&rtllib_crypt_tkip);
720	}	701	}
721		702
722
723	static void __exit rtllib_crypto_tkip_exit(void)	703	static void __exit rtllib_crypto_tkip_exit(void)
724	{	704	{
725	lib80211_unregister_crypto_ops(&rtllib_crypt_tkip);	705	lib80211_unregister_crypto_ops(&rtllib_crypt_tkip);

drivers/staging/rtl8192e/rtllib_crypt_wep.c+0−8

@@ -27,7 +27,6 @@ struct prism2_wep_data { · 26 unmodified lines
27	struct arc4_ctx tx_ctx_arc4;	27	struct arc4_ctx tx_ctx_arc4;
28	};	28	};
29		29
30
31	static void *prism2_wep_init(int keyidx)	30	static void *prism2_wep_init(int keyidx)
32	{	31	{
33	struct prism2_wep_data *priv;	32	struct prism2_wep_data *priv;
@@ -46,7 +45,6 @@ static void *prism2_wep_init(int keyidx) · 12 unmodified lines
46	return priv;	45	return priv;
47	}	46	}
48		47
49
50	static void prism2_wep_deinit(void *priv)	48	static void prism2_wep_deinit(void *priv)
51	{	49	{
52	kfree_sensitive(priv);	50	kfree_sensitive(priv);
@@ -120,7 +118,6 @@ static int prism2_wep_encrypt(struct sk_buff skb, int hdr_len, void priv) · 67 unmodified lines
120	return 0;	118	return 0;
121	}	119	}
122		120
123
124	/* Perform WEP decryption on given struct buffer. Buffer includes whole WEP	121	/* Perform WEP decryption on given struct buffer. Buffer includes whole WEP
125	* part of the frame: IV (4 bytes), encrypted payload (including SNAP header),	122	* part of the frame: IV (4 bytes), encrypted payload (including SNAP header),
126	* ICV (4 bytes). len includes both IV and ICV.	123	* ICV (4 bytes). len includes both IV and ICV.
@@ -180,7 +177,6 @@ static int prism2_wep_decrypt(struct sk_buff skb, int hdr_len, void priv) · 53 unmodified lines
180	return 0;	177	return 0;
181	}	178	}
182		179
183
184	static int prism2_wep_set_key(void key, int len, u8 seq, void *priv)	180	static int prism2_wep_set_key(void key, int len, u8 seq, void *priv)
185	{	181	{
186	struct prism2_wep_data *wep = priv;	182	struct prism2_wep_data *wep = priv;
@@ -194,7 +190,6 @@ static int prism2_wep_set_key(void key, int len, u8 seq, void *priv) · 7 unmodified lines
194	return 0;	190	return 0;
195	}	191	}
196		192
197
198	static int prism2_wep_get_key(void key, int len, u8 seq, void *priv)	193	static int prism2_wep_get_key(void key, int len, u8 seq, void *priv)
199	{	194	{
200	struct prism2_wep_data *wep = priv;	195	struct prism2_wep_data *wep = priv;
@@ -207,7 +202,6 @@ static int prism2_wep_get_key(void key, int len, u8 seq, void *priv) · 6 unmodified lines
207	return wep->key_len;	202	return wep->key_len;
208	}	203	}
209		204
210
211	static void prism2_wep_print_stats(struct seq_file m, void priv)	205	static void prism2_wep_print_stats(struct seq_file m, void priv)
212	{	206	{
213	struct prism2_wep_data *wep = priv;	207	struct prism2_wep_data *wep = priv;
@@ -231,13 +225,11 @@ static struct lib80211_crypto_ops rtllib_crypt_wep = { · 17 unmodified lines
231	.owner = THIS_MODULE,	225	.owner = THIS_MODULE,
232	};	226	};
233		227
234
235	static int __init rtllib_crypto_wep_init(void)	228	static int __init rtllib_crypto_wep_init(void)
236	{	229	{
237	return lib80211_register_crypto_ops(&rtllib_crypt_wep);	230	return lib80211_register_crypto_ops(&rtllib_crypt_wep);
238	}	231	}
239		232
240
241	static void __exit rtllib_crypto_wep_exit(void)	233	static void __exit rtllib_crypto_wep_exit(void)
242	{	234	{
243	lib80211_unregister_crypto_ops(&rtllib_crypt_wep);	235	lib80211_unregister_crypto_ops(&rtllib_crypt_wep);

drivers/staging/rtl8192e/rtllib_module.c+4−4

@@ -107,7 +107,7 @@ struct net_device *alloc_rtllib(int sizeof_priv) · 106 unmodified lines
107	spin_lock_init(&ieee->lock);	107	spin_lock_init(&ieee->lock);
108	spin_lock_init(&ieee->wpax_suitlist_lock);	108	spin_lock_init(&ieee->wpax_suitlist_lock);
109	spin_lock_init(&ieee->reorder_spinlock);	109	spin_lock_init(&ieee->reorder_spinlock);
110	atomic_set(&(ieee->atm_swbw), 0);	110	atomic_set(&ieee->atm_swbw, 0);
111		111
112	/* SAM FIXME */	112	/* SAM FIXME */
113	lib80211_crypt_info_init(&ieee->crypt_info, "RTLLIB", &ieee->lock);	113	lib80211_crypt_info_init(&ieee->crypt_info, "RTLLIB", &ieee->lock);
@@ -125,8 +125,8 @@ struct net_device *alloc_rtllib(int sizeof_priv) · 11 unmodified lines
125	if (err)	125	if (err)
126	goto free_crypt_info;	126	goto free_crypt_info;
127		127
128	ieee->pHTInfo = kzalloc(sizeof(struct rt_hi_throughput), GFP_KERNEL);	128	ieee->ht_info = kzalloc(sizeof(struct rt_hi_throughput), GFP_KERNEL);
129	if (!ieee->pHTInfo)	129	if (!ieee->ht_info)
130	goto free_softmac;	130	goto free_softmac;
131		131
132	HTUpdateDefaultSetting(ieee);	132	HTUpdateDefaultSetting(ieee);
@@ -160,7 +160,7 @@ void free_rtllib(struct net_device *dev) · 27 unmodified lines
160	struct rtllib_device ieee = (struct rtllib_device )	160	struct rtllib_device ieee = (struct rtllib_device )
161	netdev_priv_rsl(dev);	161	netdev_priv_rsl(dev);
162		162
163	kfree(ieee->pHTInfo);	163	kfree(ieee->ht_info);
164	rtllib_softmac_free(ieee);	164	rtllib_softmac_free(ieee);
165		165
166	lib80211_crypt_info_free(&ieee->crypt_info);	166	lib80211_crypt_info_free(&ieee->crypt_info);

drivers/staging/rtl8192e/rtllib_rx.c+19−19

 				    struct rtllib_rxb *prxb,
 				    struct rx_ts_record *pTS, u16 SeqNum)
 {
-	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
+	struct rt_hi_throughput *ht_info = ieee->ht_info;
 	struct rx_reorder_entry *pReorderEntry = NULL;
-	u8 WinSize = pHTInfo->rx_reorder_win_size;
+	u8 WinSize = ht_info->rx_reorder_win_size;
 	u16 WinEnd = 0;
 	u8 index = 0;
 	bool bMatchWinStart = false, bPktInBuf = false;
 		netdev_dbg(ieee->dev,
 			   "Packet Drop! IndicateSeq: %d, NewSeq: %d\n",
 			   pTS->rx_indicate_seq, SeqNum);
-		pHTInfo->rx_reorder_drop_counter++;
+		ht_info->rx_reorder_drop_counter++;
 		{
 			int i;
 		netdev_dbg(ieee->dev, "%s(): SET rx timeout timer\n", __func__);
 		pTS->rx_timeout_indicate_seq = pTS->rx_indicate_seq;
 		mod_timer(&pTS->rx_pkt_pending_timer, jiffies +
-			  msecs_to_jiffies(pHTInfo->rx_reorder_pending_time));
+			  msecs_to_jiffies(ht_info->rx_reorder_pending_time));
 	}
 	spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags);
 }
 	sc = le16_to_cpu(hdr->seq_ctl);
 	frag = WLAN_GET_SEQ_FRAG(sc);
-	if (!ieee->pHTInfo->cur_rx_reorder_enable ||
+	if (!ieee->ht_info->cur_rx_reorder_enable ||
 		!ieee->current_network.qos_data.active ||
 		!IsDataFrame(skb->data) ||
 		IsLegacyDataFrame(skb->data)) {
 	}
 	/* Filter packets sent by an STA that will be forwarded by AP */
-	if (ieee->IntelPromiscuousModeInfo.bPromiscuousOn  &&
+	if (ieee->intel_promiscuous_md_info.promiscuous_on  &&
-		ieee->IntelPromiscuousModeInfo.bFilterSourceStationFrame) {
+		ieee->intel_promiscuous_md_info.fltr_src_sta_frame) {
 		if ((fc & RTLLIB_FCTL_TODS) && !(fc & RTLLIB_FCTL_FROMDS) &&
 		    !ether_addr_equal(dst, ieee->current_network.bssid) &&
 		    ether_addr_equal(bssid, ieee->current_network.bssid)) {
 	/* Nullfunc frames may have PS-bit set, so they must be passed to
 	 * hostap_handle_sta_rx() before being dropped here.
 	 */
-	if (!ieee->IntelPromiscuousModeInfo.bPromiscuousOn) {
+	if (!ieee->intel_promiscuous_md_info.promiscuous_on) {
 		if (stype != RTLLIB_STYPE_DATA &&
 		    stype != RTLLIB_STYPE_DATA_CFACK &&
 		    stype != RTLLIB_STYPE_DATA_CFPOLL &&
 	if (unicast) {
 		if (ieee->state == RTLLIB_LINKED) {
-			if (((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod +
+			if (((ieee->link_detect_info.NumRxUnicastOkInPeriod +
-			    ieee->LinkDetectInfo.NumTxOkInPeriod) > 8) ||
+			    ieee->link_detect_info.NumTxOkInPeriod) > 8) ||
-			    (ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2)) {
+			    (ieee->link_detect_info.NumRxUnicastOkInPeriod > 2)) {
 				if (ieee->LeisurePSLeave)
 					ieee->LeisurePSLeave(ieee->dev);
 			}
 	multicast = is_multicast_ether_addr(hdr->addr1);
 	unicast = !multicast;
 	if (unicast && !ether_addr_equal(dev->dev_addr, hdr->addr1)) {
-		if (ieee->bNetPromiscuousMode)
+		if (ieee->net_promiscuous_md)
 			bToOtherSTA = true;
 		else
 			goto rx_dropped;
 	/* Update statstics for AP roaming */
 	if (!bToOtherSTA) {
-		ieee->LinkDetectInfo.NumRecvDataInPeriod++;
+		ieee->link_detect_info.NumRecvDataInPeriod++;
-		ieee->LinkDetectInfo.NumRxOkInPeriod++;
+		ieee->link_detect_info.NumRxOkInPeriod++;
 	}
 	/* Data frame - extract src/dst addresses */
 		else
 			nr_subframes = 1;
 		if (unicast)
-			ieee->LinkDetectInfo.NumRxUnicastOkInPeriod += nr_subframes;
+			ieee->link_detect_info.NumRxUnicastOkInPeriod += nr_subframes;
 		rtllib_rx_check_leave_lps(ieee, unicast, nr_subframes);
 	}
 	/* Indicate packets to upper layer or Rx Reorder */
-	if (!ieee->pHTInfo->cur_rx_reorder_enable || pTS == NULL || bToOtherSTA)
+	if (!ieee->ht_info->cur_rx_reorder_enable || pTS == NULL || bToOtherSTA)
 		rtllib_rx_indicate_pkt_legacy(ieee, rx_stats, rxb, dst, src);
 	else
 		RxReorderIndicatePacket(ieee, rxb, pTS, SeqNum);
 		hdrlen += 4;
 	}
-	rtllib_monitor_rx(ieee, skb, rx_stats, hdrlen);
 	ieee->stats.rx_packets++;
 	ieee->stats.rx_bytes += skb->len;
+	rtllib_monitor_rx(ieee, skb, rx_stats, hdrlen);
 	return 1;
 }
 				if (rtllib_act_scanning(ieee, false) &&
 				    ieee->FirstIe_InScan)
 					netdev_info(ieee->dev,
-						    "Received beacon ContryIE, SSID: <%s>\n",
+						    "Received beacon CountryIE, SSID: <%s>\n",
 						    network->ssid);
 				dot11d_update_country(ieee, addr2,
 						       info_element->len,
 		}
 		if (is_beacon(frame_ctl)) {
 			if (ieee->state >= RTLLIB_LINKED)
-				ieee->LinkDetectInfo.NumRecvBcnInPeriod++;
+				ieee->link_detect_info.NumRecvBcnInPeriod++;
 		}
 	}
 	list_for_each_entry(target, &ieee->network_list, list) {

drivers/staging/rtl8192e/rtllib_softmac.c+86−87

 }
-u8
+u8 MgntQuery_TxRateExcludeCCKRates(struct rtllib_device *ieee)
-MgntQuery_TxRateExcludeCCKRates(struct rtllib_device *ieee)
 {
 	u16	i;
 	u8	QueryRate = 0;
 static u8 MgntQuery_MgntFrameTxRate(struct rtllib_device *ieee)
 {
-	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
+	struct rt_hi_throughput *ht_info = ieee->ht_info;
 	u8 rate;
-	if (pHTInfo->iot_action & HT_IOT_ACT_MGNT_USE_CCK_6M)
+	if (ht_info->iot_action & HT_IOT_ACT_MGNT_USE_CCK_6M)
 		rate = 0x0c;
 	else
 		rate = ieee->basic_rate & 0x7f;
 	if (rate == 0) {
 		if (ieee->mode == IEEE_A ||
 		   ieee->mode == IEEE_N_5G ||
-		   (ieee->mode == IEEE_N_24G && !pHTInfo->bCurSuppCCK))
+		   (ieee->mode == IEEE_N_24G && !ht_info->bCurSuppCCK))
 			rate = 0x0c;
 		else
 			rate = 0x02;
 	tcb_desc->data_rate = MgntQuery_MgntFrameTxRate(ieee);
 	tcb_desc->RATRIndex = 7;
-	tcb_desc->bTxDisableRateFallBack = 1;
+	tcb_desc->tx_dis_rate_fallback = 1;
-	tcb_desc->bTxUseDriverAssingedRate = 1;
+	tcb_desc->tx_use_drv_assinged_rate = 1;
 	if (single) {
 		if (ieee->queue_stop) {
 			enqueue_mgmt(ieee, skb);
 	tcb_desc->data_rate = MgntQuery_MgntFrameTxRate(ieee);
 	tcb_desc->RATRIndex = 7;
-	tcb_desc->bTxDisableRateFallBack = 1;
+	tcb_desc->tx_dis_rate_fallback = 1;
-	tcb_desc->bTxUseDriverAssingedRate = 1;
+	tcb_desc->tx_use_drv_assinged_rate = 1;
 	if (single) {
 		if (type != RTLLIB_FTYPE_CTL) {
 			header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4);
 	ieee->SetHwRegHandler(dev, HW_VAR_CECHK_BSSID,
 			     (u8 *)&bFilterOutNonAssociatedBSSID);
-	ieee->bNetPromiscuousMode = true;
+	ieee->net_promiscuous_md = true;
 }
 EXPORT_SYMBOL(rtllib_EnableIntelPromiscuousMode);
 	ieee->SetHwRegHandler(dev, HW_VAR_CECHK_BSSID,
 			     (u8 *)&bFilterOutNonAssociatedBSSID);
-	ieee->bNetPromiscuousMode = false;
+	ieee->net_promiscuous_md = false;
 }
 EXPORT_SYMBOL(rtllib_DisableIntelPromiscuousMode);
 	u8 tmp_ht_cap_len = 0;
 	u8 *tmp_ht_info_buf = NULL;
 	u8 tmp_ht_info_len = 0;
-	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
+	struct rt_hi_throughput *ht_info = ieee->ht_info;
 	u8 *tmp_generic_ie_buf = NULL;
 	u8 tmp_generic_ie_len = 0;
 	if ((ieee->current_network.mode == IEEE_G) ||
 	   (ieee->current_network.mode == IEEE_N_24G &&
-	   ieee->pHTInfo->bCurSuppCCK)) {
+	   ieee->ht_info->bCurSuppCCK)) {
 		erp_len = 3;
 		erpinfo_content = 0;
 		if (ieee->current_network.buseprotection)
 	crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
 	encrypt = ieee->host_encrypt && crypt && crypt->ops &&
 		((strcmp(crypt->ops->name, "R-WEP") == 0 || wpa_ie_len));
-	if (ieee->pHTInfo->bCurrentHTSupport) {
+	if (ieee->ht_info->bCurrentHTSupport) {
-		tmp_ht_cap_buf = (u8 *)&(ieee->pHTInfo->SelfHTCap);
+		tmp_ht_cap_buf = (u8 *)&(ieee->ht_info->SelfHTCap);
-		tmp_ht_cap_len = sizeof(ieee->pHTInfo->SelfHTCap);
+		tmp_ht_cap_len = sizeof(ieee->ht_info->SelfHTCap);
-		tmp_ht_info_buf = (u8 *)&(ieee->pHTInfo->SelfHTInfo);
+		tmp_ht_info_buf = (u8 *)&(ieee->ht_info->SelfHTInfo);
-		tmp_ht_info_len = sizeof(ieee->pHTInfo->SelfHTInfo);
+		tmp_ht_info_len = sizeof(ieee->ht_info->SelfHTInfo);
 		HTConstructCapabilityElement(ieee, tmp_ht_cap_buf,
 					     &tmp_ht_cap_len, encrypt, false);
 		HTConstructInfoElement(ieee, tmp_ht_info_buf, &tmp_ht_info_len,
 				       encrypt);
-		if (pHTInfo->reg_rt2rt_aggregation) {
+		if (ht_info->reg_rt2rt_aggregation) {
-			tmp_generic_ie_buf = ieee->pHTInfo->sz_rt2rt_agg_buf;
+			tmp_generic_ie_buf = ieee->ht_info->sz_rt2rt_agg_buf;
 			tmp_generic_ie_len =
-				 sizeof(ieee->pHTInfo->sz_rt2rt_agg_buf);
+				 sizeof(ieee->ht_info->sz_rt2rt_agg_buf);
 			HTConstructRT2RTAggElement(ieee, tmp_generic_ie_buf,
 						   &tmp_generic_ie_len);
 		}
 	if ((ieee->rtllib_ap_sec_type &&
 	    (ieee->rtllib_ap_sec_type(ieee) & SEC_ALG_TKIP)) ||
 	    ieee->bForcedBgMode) {
-		ieee->pHTInfo->bEnableHT = 0;
+		ieee->ht_info->enable_ht = 0;
 		ieee->mode = WIRELESS_MODE_G;
 	}
-	if (ieee->pHTInfo->bCurrentHTSupport && ieee->pHTInfo->bEnableHT) {
+	if (ieee->ht_info->bCurrentHTSupport && ieee->ht_info->enable_ht) {
-		ht_cap_buf = (u8 *)&(ieee->pHTInfo->SelfHTCap);
+		ht_cap_buf = (u8 *)&(ieee->ht_info->SelfHTCap);
-		ht_cap_len = sizeof(ieee->pHTInfo->SelfHTCap);
+		ht_cap_len = sizeof(ieee->ht_info->SelfHTCap);
 		HTConstructCapabilityElement(ieee, ht_cap_buf, &ht_cap_len,
 					     encrypt, true);
-		if (ieee->pHTInfo->current_rt2rt_aggregation) {
+		if (ieee->ht_info->current_rt2rt_aggregation) {
-			realtek_ie_buf = ieee->pHTInfo->sz_rt2rt_agg_buf;
+			realtek_ie_buf = ieee->ht_info->sz_rt2rt_agg_buf;
 			realtek_ie_len =
-				 sizeof(ieee->pHTInfo->sz_rt2rt_agg_buf);
+				 sizeof(ieee->ht_info->sz_rt2rt_agg_buf);
 			HTConstructRT2RTAggElement(ieee, realtek_ie_buf,
 						   &realtek_ie_len);
 		}
 		memcpy(tag, osCcxVerNum.Octet, osCcxVerNum.Length);
 		tag += osCcxVerNum.Length;
 	}
-	if (ieee->pHTInfo->bCurrentHTSupport && ieee->pHTInfo->bEnableHT) {
+	if (ieee->ht_info->bCurrentHTSupport && ieee->ht_info->enable_ht) {
-		if (ieee->pHTInfo->ePeerHTSpecVer != HT_SPEC_VER_EWC) {
+		if (ieee->ht_info->ePeerHTSpecVer != HT_SPEC_VER_EWC) {
 			tag = skb_put(skb, ht_cap_len);
 			*tag++ = MFIE_TYPE_HT_CAP;
 			*tag++ = ht_cap_len - 2;
 		rtllib_TURBO_Info(ieee, &tag);
 	}
-	if (ieee->pHTInfo->bCurrentHTSupport && ieee->pHTInfo->bEnableHT) {
+	if (ieee->ht_info->bCurrentHTSupport && ieee->ht_info->enable_ht) {
-		if (ieee->pHTInfo->ePeerHTSpecVer == HT_SPEC_VER_EWC) {
+		if (ieee->ht_info->ePeerHTSpecVer == HT_SPEC_VER_EWC) {
 			tag = skb_put(skb, ht_cap_len);
 			*tag++ = MFIE_TYPE_GENERIC;
 			*tag++ = ht_cap_len - 2;
 			tag += ht_cap_len - 2;
 		}
-		if (ieee->pHTInfo->current_rt2rt_aggregation) {
+		if (ieee->ht_info->current_rt2rt_aggregation) {
 			tag = skb_put(skb, realtek_ie_len);
 			*tag++ = MFIE_TYPE_GENERIC;
 			*tag++ = realtek_ie_len - 2;
 				     container_of_work_rsl(data,
 				     struct rtllib_device,
 				     associate_complete_wq);
-	struct rt_pwr_save_ctrl *pPSC = &(ieee->PowerSaveControl);
+	struct rt_pwr_save_ctrl *psc = &ieee->pwr_save_ctrl;
 	netdev_info(ieee->dev, "Associated successfully with %pM\n",
 		    ieee->current_network.bssid);
 		ieee->SetWirelessMode(ieee->dev, IEEE_B);
 		netdev_info(ieee->dev, "Using B rates:%d\n", ieee->rate);
 	}
-	if (ieee->pHTInfo->bCurrentHTSupport && ieee->pHTInfo->bEnableHT) {
+	if (ieee->ht_info->bCurrentHTSupport && ieee->ht_info->enable_ht) {
 		netdev_info(ieee->dev, "Successfully associated, ht enabled\n");
 		HTOnAssocRsp(ieee);
 	} else {
 		netdev_info(ieee->dev,
 			    "Successfully associated, ht not enabled(%d, %d)\n",
-			    ieee->pHTInfo->bCurrentHTSupport,
+			    ieee->ht_info->bCurrentHTSupport,
-			    ieee->pHTInfo->bEnableHT);
+			    ieee->ht_info->enable_ht);
-		memset(ieee->dot11HTOperationalRateSet, 0, 16);
+		memset(ieee->dot11ht_oper_rate_set, 0, 16);
 	}
-	ieee->LinkDetectInfo.SlotNum = 2 * (1 +
+	ieee->link_detect_info.SlotNum = 2 * (1 +
 				       ieee->current_network.beacon_interval /
 				       500);
-	if (ieee->LinkDetectInfo.NumRecvBcnInPeriod == 0 ||
+	if (ieee->link_detect_info.NumRecvBcnInPeriod == 0 ||
-	    ieee->LinkDetectInfo.NumRecvDataInPeriod == 0) {
+	    ieee->link_detect_info.NumRecvDataInPeriod == 0) {
-		ieee->LinkDetectInfo.NumRecvBcnInPeriod = 1;
+		ieee->link_detect_info.NumRecvBcnInPeriod = 1;
-		ieee->LinkDetectInfo.NumRecvDataInPeriod = 1;
+		ieee->link_detect_info.NumRecvDataInPeriod = 1;
 	}
-	pPSC->LpsIdleCount = 0;
+	psc->LpsIdleCount = 0;
 	ieee->link_change(ieee->dev);
 	if (ieee->is_silent_reset) {
 				    ieee->current_network.ssid,
 				    ieee->current_network.channel,
 				    ieee->current_network.qos_data.supported,
-				    ieee->pHTInfo->bEnableHT,
+				    ieee->ht_info->enable_ht,
 				    ieee->current_network.bssht.bd_support_ht,
 				    ieee->current_network.mode,
 				    ieee->current_network.flags);
 			   !(ieee->softmac_features & IEEE_SOFTMAC_SCAN))
 				rtllib_stop_scan_syncro(ieee);
-			HTResetIOTSetting(ieee->pHTInfo);
+			HTResetIOTSetting(ieee->ht_info);
 			ieee->wmm_acm = 0;
 			if (ieee->iw_mode == IW_MODE_INFRA) {
 				/* Join the network for the first time */
 					HTResetSelfAndSavePeerSetting(ieee,
 						 &(ieee->current_network));
 				else
-					ieee->pHTInfo->bCurrentHTSupport =
+					ieee->ht_info->bCurrentHTSupport =
 								 false;
 				ieee->state = RTLLIB_ASSOCIATING;
 					netdev_info(ieee->dev,
 						    "Using B rates\n");
 				}
-				memset(ieee->dot11HTOperationalRateSet, 0, 16);
+				memset(ieee->dot11ht_oper_rate_set, 0, 16);
 				ieee->state = RTLLIB_LINKED;
 			}
 		}
 	   ((ieee->mode == IEEE_G) &&
 	   (ieee->current_network.mode == IEEE_N_24G) &&
 	   (ieee->AsocRetryCount++ < (RT_ASOC_RETRY_LIMIT-1)))) {
-		ieee->pHTInfo->iot_action |= HT_IOT_ACT_PURE_N_MODE;
+		ieee->ht_info->iot_action |= HT_IOT_ACT_PURE_N_MODE;
 	} else {
 		ieee->AsocRetryCount = 0;
 	}
 {
 	int timeout;
 	u8 dtim;
-	struct rt_pwr_save_ctrl *pPSC = &(ieee->PowerSaveControl);
+	struct rt_pwr_save_ctrl *psc = &ieee->pwr_save_ctrl;
 	if (ieee->LPSDelayCnt) {
 		ieee->LPSDelayCnt--;
 	if (time) {
 		if (ieee->bAwakePktSent) {
-			pPSC->LPSAwakeIntvl = 1;
+			psc->LPSAwakeIntvl = 1;
 		} else {
 			u8 MaxPeriod = 1;
-			if (pPSC->LPSAwakeIntvl == 0)
+			if (psc->LPSAwakeIntvl == 0)
-				pPSC->LPSAwakeIntvl = 1;
+				psc->LPSAwakeIntvl = 1;
-			if (pPSC->RegMaxLPSAwakeIntvl == 0)
+			if (psc->reg_max_lps_awake_intvl == 0)
 				MaxPeriod = 1;
-			else if (pPSC->RegMaxLPSAwakeIntvl == 0xFF)
+			else if (psc->reg_max_lps_awake_intvl == 0xFF)
 				MaxPeriod = ieee->current_network.dtim_period;
 			else
-				MaxPeriod = pPSC->RegMaxLPSAwakeIntvl;
+				MaxPeriod = psc->reg_max_lps_awake_intvl;
-			pPSC->LPSAwakeIntvl = (pPSC->LPSAwakeIntvl >=
+			psc->LPSAwakeIntvl = (psc->LPSAwakeIntvl >=
 					       MaxPeriod) ? MaxPeriod :
-					       (pPSC->LPSAwakeIntvl + 1);
+					       (psc->LPSAwakeIntvl + 1);
 		}
 		{
 			u8 LPSAwakeIntvl_tmp = 0;
 			u8 count = ieee->current_network.tim.tim_count;
 			if (count == 0) {
-				if (pPSC->LPSAwakeIntvl > period)
+				if (psc->LPSAwakeIntvl > period)
 					LPSAwakeIntvl_tmp = period +
-						 (pPSC->LPSAwakeIntvl -
+						 (psc->LPSAwakeIntvl -
 						 period) -
-						 ((pPSC->LPSAwakeIntvl-period) %
+						 ((psc->LPSAwakeIntvl-period) %
 						 period);
 				else
-					LPSAwakeIntvl_tmp = pPSC->LPSAwakeIntvl;
+					LPSAwakeIntvl_tmp = psc->LPSAwakeIntvl;
 			} else {
-				if (pPSC->LPSAwakeIntvl >
+				if (psc->LPSAwakeIntvl >
 				    ieee->current_network.tim.tim_count)
 					LPSAwakeIntvl_tmp = count +
-					(pPSC->LPSAwakeIntvl - count) -
+					(psc->LPSAwakeIntvl - count) -
-					((pPSC->LPSAwakeIntvl-count)%period);
+					((psc->LPSAwakeIntvl-count)%period);
 				else
-					LPSAwakeIntvl_tmp = pPSC->LPSAwakeIntvl;
+					LPSAwakeIntvl_tmp = psc->LPSAwakeIntvl;
 			}
 		*time = ieee->current_network.last_dtim_sta_time
 {
 	if (ieee->sta_sleep == LPS_IS_WAKE) {
 		if (nl) {
-			if (ieee->pHTInfo->iot_action &
+			if (ieee->ht_info->iot_action &
 			    HT_IOT_ACT_NULL_DATA_POWER_SAVING) {
 				ieee->ack_tx_to_ieee = 1;
 				rtllib_sta_ps_send_null_frame(ieee, 0);
 	if (ieee->sta_sleep == LPS_IS_SLEEP)
 		ieee->sta_wake_up(ieee->dev);
 	if (nl) {
-		if (ieee->pHTInfo->iot_action &
+		if (ieee->ht_info->iot_action &
 		    HT_IOT_ACT_NULL_DATA_POWER_SAVING) {
 			ieee->ack_tx_to_ieee = 1;
 			rtllib_sta_ps_send_null_frame(ieee, 0);
 		if ((ieee->sta_sleep == LPS_IS_WAKE) && !success) {
 			spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
-			if (ieee->pHTInfo->iot_action &
+			if (ieee->ht_info->iot_action &
 			    HT_IOT_ACT_NULL_DATA_POWER_SAVING)
 				rtllib_sta_ps_send_null_frame(ieee, 0);
 			else
 					kfree(network);
 					return 1;
 				}
-				memcpy(ieee->pHTInfo->PeerHTCapBuf,
+				memcpy(ieee->ht_info->PeerHTCapBuf,
 				       network->bssht.bd_ht_cap_buf,
 				       network->bssht.bd_ht_cap_len);
-				memcpy(ieee->pHTInfo->PeerHTInfoBuf,
+				memcpy(ieee->ht_info->PeerHTInfoBuf,
 				       network->bssht.bd_ht_info_buf,
 				       network->bssht.bd_ht_info_len);
 				if (ieee->handle_assoc_response != NULL)
 	if (ieee->open_wep || !challenge) {
 		ieee->state = RTLLIB_ASSOCIATING_AUTHENTICATED;
 		ieee->softmac_stats.rx_auth_rs_ok++;
-		if (!(ieee->pHTInfo->iot_action & HT_IOT_ACT_PURE_N_MODE)) {
+		if (!(ieee->ht_info->iot_action & HT_IOT_ACT_PURE_N_MODE)) {
 			if (!ieee->GetNmodeSupportBySecCfg(ieee->dev)) {
 				if (IsHTHalfNmodeAPs(ieee)) {
 					bSupportNmode = true;
 		ieee->state = RTLLIB_ASSOCIATING;
 		ieee->softmac_stats.reassoc++;
 		ieee->is_roaming = true;
-		ieee->LinkDetectInfo.bBusyTraffic = false;
+		ieee->link_detect_info.bBusyTraffic = false;
 		rtllib_disassociate(ieee);
 		RemovePeerTS(ieee, header->addr2);
 		if (ieee->LedControlHandler != NULL)
 	if ((ieee->mode == IEEE_N_24G) || (ieee->mode == IEEE_N_5G))
 		HTUseDefaultSetting(ieee);
 	else
-		ieee->pHTInfo->bCurrentHTSupport = false;
+		ieee->ht_info->bCurrentHTSupport = false;
 	ieee->SetHwRegHandler(ieee->dev, HW_VAR_MEDIA_STATUS,
 			      (u8 *)(&ieee->state));
 	if (!ieee->dot11d_info)
 		return -ENOMEM;
-	ieee->LinkDetectInfo.SlotIndex = 0;
+	ieee->link_detect_info.SlotIndex = 0;
-	ieee->LinkDetectInfo.SlotNum = 2;
+	ieee->link_detect_info.SlotNum = 2;
-	ieee->LinkDetectInfo.NumRecvBcnInPeriod = 0;
+	ieee->link_detect_info.NumRecvBcnInPeriod = 0;
-	ieee->LinkDetectInfo.NumRecvDataInPeriod = 0;
+	ieee->link_detect_info.NumRecvDataInPeriod = 0;
-	ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
+	ieee->link_detect_info.NumTxOkInPeriod = 0;
-	ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
+	ieee->link_detect_info.NumRxOkInPeriod = 0;
-	ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
+	ieee->link_detect_info.NumRxUnicastOkInPeriod = 0;
 	ieee->bIsAggregateFrame = false;
 	ieee->assoc_id = 0;
 	ieee->queue_stop = 0;
 	ieee->ps = RTLLIB_PS_DISABLED;
 	ieee->sta_sleep = LPS_IS_WAKE;
-	ieee->Regdot11HTOperationalRateSet[0] = 0xff;
+	ieee->reg_dot11ht_oper_rate_set[0] = 0xff;
-	ieee->Regdot11HTOperationalRateSet[1] = 0xff;
+	ieee->reg_dot11ht_oper_rate_set[1] = 0xff;
-	ieee->Regdot11HTOperationalRateSet[4] = 0x01;
+	ieee->reg_dot11ht_oper_rate_set[4] = 0x01;
-	ieee->Regdot11TxHTOperationalRateSet[0] = 0xff;
+	ieee->reg_dot11tx_ht_oper_rate_set[0] = 0xff;
-	ieee->Regdot11TxHTOperationalRateSet[1] = 0xff;
+	ieee->reg_dot11tx_ht_oper_rate_set[1] = 0xff;
-	ieee->Regdot11TxHTOperationalRateSet[4] = 0x01;
+	ieee->reg_dot11tx_ht_oper_rate_set[4] = 0x01;
 	ieee->FirstIe_InScan = false;
 	ieee->actscanning = false;

drivers/staging/rtl8192e/rtllib_softmac_wx.c+9−10

 	if (ieee->ScanOperationBackupHandler)
 		ieee->ScanOperationBackupHandler(ieee->dev, SCAN_OPT_BACKUP);
-	if (ieee->pHTInfo->bCurrentHTSupport && ieee->pHTInfo->bEnableHT &&
+	if (ieee->ht_info->bCurrentHTSupport && ieee->ht_info->enable_ht &&
-	    ieee->pHTInfo->bCurBW40MHz) {
+	    ieee->ht_info->bCurBW40MHz) {
 		b40M = 1;
-		chan_offset = ieee->pHTInfo->CurSTAExtChnlOffset;
+		chan_offset = ieee->ht_info->CurSTAExtChnlOffset;
-		bandwidth = (enum ht_channel_width)ieee->pHTInfo->bCurBW40MHz;
+		bandwidth = (enum ht_channel_width)ieee->ht_info->bCurBW40MHz;
 		ieee->SetBWModeHandler(ieee->dev, HT_CHANNEL_WIDTH_20,
 				       HT_EXTCHNL_OFFSET_NO_EXT);
 	}
 	/* Notify AP that I wake up again */
 	rtllib_sta_ps_send_null_frame(ieee, 0);
-	if (ieee->LinkDetectInfo.NumRecvBcnInPeriod == 0 ||
+	if (ieee->link_detect_info.NumRecvBcnInPeriod == 0 ||
-	    ieee->LinkDetectInfo.NumRecvDataInPeriod == 0) {
+	    ieee->link_detect_info.NumRecvDataInPeriod == 0) {
-		ieee->LinkDetectInfo.NumRecvBcnInPeriod = 1;
+		ieee->link_detect_info.NumRecvBcnInPeriod = 1;
-		ieee->LinkDetectInfo.NumRecvDataInPeriod = 1;
+		ieee->link_detect_info.NumRecvDataInPeriod = 1;
 	}
 	if (ieee->data_hard_resume)
 		ieee->ps = RTLLIB_PS_DISABLED;
 		goto exit;
 	}
-	if (wrqu->power.flags & IW_POWER_TIMEOUT) {
+	if (wrqu->power.flags & IW_POWER_TIMEOUT)
 		ieee->ps_timeout = wrqu->power.value / 1000;
-	}
 	if (wrqu->power.flags & IW_POWER_PERIOD)
 		ieee->ps_period = wrqu->power.value / 1000;

drivers/staging/rtl8192e/rtllib_tx.c+57−63

@@ -191,7 +191,6 @@ int rtllib_encrypt_fragment(struct rtllib_device ieee, struct sk_buff frag, · 190 unmodified lines
191	return 0;	191	return 0;
192	}	192	}
193		193
194
195	void rtllib_txb_free(struct rtllib_txb *txb)	194	void rtllib_txb_free(struct rtllib_txb *txb)
196	{	195	{
197	if (unlikely(!txb))	196	if (unlikely(!txb))
@@ -267,14 +266,14 @@ static void rtllib_tx_query_agg_cap(struct rtllib_device *ieee, · 69 unmodified lines
267	struct sk_buff *skb,	266	struct sk_buff *skb,
268	struct cb_desc *tcb_desc)	267	struct cb_desc *tcb_desc)
269	{	268	{
270	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	269	struct rt_hi_throughput *ht_info = ieee->ht_info;
271	struct tx_ts_record *pTxTs = NULL;	270	struct tx_ts_record *pTxTs = NULL;
272	struct rtllib_hdr_1addr hdr = (struct rtllib_hdr_1addr )skb->data;	271	struct rtllib_hdr_1addr hdr = (struct rtllib_hdr_1addr )skb->data;
273		272
274	if (rtllib_act_scanning(ieee, false))	273	if (rtllib_act_scanning(ieee, false))
275	return;	274	return;
276		275
277	if (!pHTInfo->bCurrentHTSupport \|\| !pHTInfo->bEnableHT)	276	if (!ht_info->bCurrentHTSupport \|\| !ht_info->enable_ht)
278	return;	277	return;
279	if (!IsQoSDataFrame(skb->data))	278	if (!IsQoSDataFrame(skb->data))
280	return;	279	return;
@@ -284,14 +283,14 @@ static void rtllib_tx_query_agg_cap(struct rtllib_device *ieee, · 3 unmodified lines
284	if (tcb_desc->bdhcp \|\| ieee->CntAfterLink < 2)	283	if (tcb_desc->bdhcp \|\| ieee->CntAfterLink < 2)
285	return;	284	return;
286		285
287	if (pHTInfo->iot_action & HT_IOT_ACT_TX_NO_AGGREGATION)	286	if (ht_info->iot_action & HT_IOT_ACT_TX_NO_AGGREGATION)
288	return;	287	return;
289		288
290	if (!ieee->GetNmodeSupportBySecCfg(ieee->dev))	289	if (!ieee->GetNmodeSupportBySecCfg(ieee->dev))
291	return;	290	return;
292	if (pHTInfo->bCurrentAMPDUEnable) {	291	if (ht_info->bCurrentAMPDUEnable) {
293	if (!GetTs(ieee, (struct ts_common_info **)(&pTxTs), hdr->addr1,	292	if (!GetTs(ieee, (struct ts_common_info **)(&pTxTs), hdr->addr1,
294	skb->priority, TX_DIR, true)) {	293	skb->priority, TX_DIR, true)) {
295	netdev_info(ieee->dev, "%s: can't get TS\n", __func__);	294	netdev_info(ieee->dev, "%s: can't get TS\n", __func__);
296	return;	295	return;
297	}	296	}
@@ -307,26 +306,26 @@ static void rtllib_tx_query_agg_cap(struct rtllib_device *ieee, · 9 unmodified lines
307	goto FORCED_AGG_SETTING;	306	goto FORCED_AGG_SETTING;
308	} else if (!pTxTs->bUsingBa) {	307	} else if (!pTxTs->bUsingBa) {
309	if (SN_LESS(pTxTs->TxAdmittedBARecord.ba_start_seq_ctrl.field.seq_num,	308	if (SN_LESS(pTxTs->TxAdmittedBARecord.ba_start_seq_ctrl.field.seq_num,
310	(pTxTs->TxCurSeq+1)%4096))	309	(pTxTs->TxCurSeq + 1) % 4096))
311	pTxTs->bUsingBa = true;	310	pTxTs->bUsingBa = true;
312	else	311	else
313	goto FORCED_AGG_SETTING;	312	goto FORCED_AGG_SETTING;
314	}	313	}
315	if (ieee->iw_mode == IW_MODE_INFRA) {	314	if (ieee->iw_mode == IW_MODE_INFRA) {
316	tcb_desc->bAMPDUEnable = true;	315	tcb_desc->bAMPDUEnable = true;
317	tcb_desc->ampdu_factor = pHTInfo->CurrentAMPDUFactor;	316	tcb_desc->ampdu_factor = ht_info->CurrentAMPDUFactor;
318	tcb_desc->ampdu_density = pHTInfo->current_mpdu_density;	317	tcb_desc->ampdu_density = ht_info->current_mpdu_density;
319	}	318	}
320	}	319	}
321	FORCED_AGG_SETTING:	320	FORCED_AGG_SETTING:
322	switch (pHTInfo->ForcedAMPDUMode) {	321	switch (ht_info->ForcedAMPDUMode) {
323	case HT_AGG_AUTO:	322	case HT_AGG_AUTO:
324	break;	323	break;
325		324
326	case HT_AGG_FORCE_ENABLE:	325	case HT_AGG_FORCE_ENABLE:
327	tcb_desc->bAMPDUEnable = true;	326	tcb_desc->bAMPDUEnable = true;
328	tcb_desc->ampdu_density = pHTInfo->forced_mpdu_density;	327	tcb_desc->ampdu_density = ht_info->forced_mpdu_density;
329	tcb_desc->ampdu_factor = pHTInfo->forced_ampdu_factor;	328	tcb_desc->ampdu_factor = ht_info->forced_ampdu_factor;
330	break;	329	break;
331		330
332	case HT_AGG_FORCE_DISABLE:	331	case HT_AGG_FORCE_DISABLE:
@@ -351,32 +350,32 @@ static void rtllib_query_ShortPreambleMode(struct rtllib_device *ieee, · 18 unmodified lines
351	static void rtllib_query_HTCapShortGI(struct rtllib_device *ieee,	350	static void rtllib_query_HTCapShortGI(struct rtllib_device *ieee,
352	struct cb_desc *tcb_desc)	351	struct cb_desc *tcb_desc)
353	{	352	{
354	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	353	struct rt_hi_throughput *ht_info = ieee->ht_info;
355		354
356	tcb_desc->bUseShortGI = false;	355	tcb_desc->bUseShortGI = false;
357		356
358	if (!pHTInfo->bCurrentHTSupport \|\| !pHTInfo->bEnableHT)	357	if (!ht_info->bCurrentHTSupport \|\| !ht_info->enable_ht)
359	return;	358	return;
360		359
361	if (pHTInfo->forced_short_gi) {	360	if (ht_info->forced_short_gi) {
362	tcb_desc->bUseShortGI = true;	361	tcb_desc->bUseShortGI = true;
363	return;	362	return;
364	}	363	}
365		364
366	if (pHTInfo->bCurBW40MHz && pHTInfo->bCurShortGI40MHz)	365	if (ht_info->bCurBW40MHz && ht_info->bCurShortGI40MHz)
367	tcb_desc->bUseShortGI = true;	366	tcb_desc->bUseShortGI = true;
368	else if (!pHTInfo->bCurBW40MHz && pHTInfo->bCurShortGI20MHz)	367	else if (!ht_info->bCurBW40MHz && ht_info->bCurShortGI20MHz)
369	tcb_desc->bUseShortGI = true;	368	tcb_desc->bUseShortGI = true;
370	}	369	}
371		370
372	static void rtllib_query_BandwidthMode(struct rtllib_device *ieee,	371	static void rtllib_query_BandwidthMode(struct rtllib_device *ieee,
373	struct cb_desc *tcb_desc)	372	struct cb_desc *tcb_desc)
374	{	373	{
375	struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;	374	struct rt_hi_throughput *ht_info = ieee->ht_info;
376		375
377	tcb_desc->bPacketBW = false;	376	tcb_desc->bPacketBW = false;
378		377
379	if (!pHTInfo->bCurrentHTSupport \|\| !pHTInfo->bEnableHT)	378	if (!ht_info->bCurrentHTSupport \|\| !ht_info->enable_ht)
380	return;	379	return;
381		380
382	if (tcb_desc->bMulticast \|\| tcb_desc->bBroadcast)	381	if (tcb_desc->bMulticast \|\| tcb_desc->bBroadcast)
@@ -384,7 +383,7 @@ static void rtllib_query_BandwidthMode(struct rtllib_device *ieee, · 1 unmodified line
384		383
385	if ((tcb_desc->data_rate & 0x80) == 0)	384	if ((tcb_desc->data_rate & 0x80) == 0)
386	return;	385	return;
387	if (pHTInfo->bCurBW40MHz && pHTInfo->cur_tx_bw40mhz &&	386	if (ht_info->bCurBW40MHz && ht_info->cur_tx_bw40mhz &&
388	!ieee->bandwidth_auto_switch.bforced_tx20Mhz)	387	!ieee->bandwidth_auto_switch.bforced_tx20Mhz)
389	tcb_desc->bPacketBW = true;	388	tcb_desc->bPacketBW = true;
390	}	389	}
@@ -393,7 +392,7 @@ static void rtllib_query_protectionmode(struct rtllib_device *ieee, · 2 unmodified lines
393	struct cb_desc *tcb_desc,	392	struct cb_desc *tcb_desc,
394	struct sk_buff *skb)	393	struct sk_buff *skb)
395	{	394	{
396	struct rt_hi_throughput *pHTInfo;	395	struct rt_hi_throughput *ht_info;
397		396
398	tcb_desc->bRTSSTBC = false;	397	tcb_desc->bRTSSTBC = false;
399	tcb_desc->bRTSUseShortGI = false;	398	tcb_desc->bRTSUseShortGI = false;
@@ -404,7 +403,7 @@ static void rtllib_query_protectionmode(struct rtllib_device *ieee, · 4 unmodified lines
404	if (tcb_desc->bBroadcast \|\| tcb_desc->bMulticast)	403	if (tcb_desc->bBroadcast \|\| tcb_desc->bMulticast)
405	return;	404	return;
406		405
407	if (is_broadcast_ether_addr(skb->data+16))	406	if (is_broadcast_ether_addr(skb->data + 16))
408	return;	407	return;
409		408
410	if (ieee->mode < IEEE_N_24G) {	409	if (ieee->mode < IEEE_N_24G) {
@@ -419,15 +418,15 @@ static void rtllib_query_protectionmode(struct rtllib_device *ieee, · 8 unmodified lines
419	return;	418	return;
420	}	419	}
421		420
422	pHTInfo = ieee->pHTInfo;	421	ht_info = ieee->ht_info;
423		422
424	while (true) {	423	while (true) {
425	if (pHTInfo->iot_action & HT_IOT_ACT_FORCED_CTS2SELF) {	424	if (ht_info->iot_action & HT_IOT_ACT_FORCED_CTS2SELF) {
426	tcb_desc->bCTSEnable = true;	425	tcb_desc->bCTSEnable = true;
427	tcb_desc->rts_rate = MGN_24M;	426	tcb_desc->rts_rate = MGN_24M;
428	tcb_desc->bRTSEnable = true;	427	tcb_desc->bRTSEnable = true;
429	break;	428	break;
430	} else if (pHTInfo->iot_action & (HT_IOT_ACT_FORCED_RTS \|	429	} else if (ht_info->iot_action & (HT_IOT_ACT_FORCED_RTS \|
431	HT_IOT_ACT_PURE_N_MODE)) {	430	HT_IOT_ACT_PURE_N_MODE)) {
432	tcb_desc->bRTSEnable = true;	431	tcb_desc->bRTSEnable = true;
433	tcb_desc->rts_rate = MGN_24M;	432	tcb_desc->rts_rate = MGN_24M;
@@ -439,12 +438,12 @@ static void rtllib_query_protectionmode(struct rtllib_device *ieee, · 5 unmodified lines
439	tcb_desc->rts_rate = MGN_24M;	438	tcb_desc->rts_rate = MGN_24M;
440	break;	439	break;
441	}	440	}
442	if (pHTInfo->bCurrentHTSupport && pHTInfo->bEnableHT) {	441	if (ht_info->bCurrentHTSupport && ht_info->enable_ht) {
443	u8 HTOpMode = pHTInfo->current_op_mode;	442	u8 HTOpMode = ht_info->current_op_mode;
444		443
445	if ((pHTInfo->bCurBW40MHz && (HTOpMode == 2 \|\|	444	if ((ht_info->bCurBW40MHz && (HTOpMode == 2 \|\|
446	HTOpMode == 3)) \|\|	445	HTOpMode == 3)) \|\|
447	(!pHTInfo->bCurBW40MHz && HTOpMode == 3)) {	446	(!ht_info->bCurBW40MHz && HTOpMode == 3)) {
448	tcb_desc->rts_rate = MGN_24M;	447	tcb_desc->rts_rate = MGN_24M;
449	tcb_desc->bRTSEnable = true;	448	tcb_desc->bRTSEnable = true;
450	break;	449	break;
@@ -475,17 +474,16 @@ NO_PROTECTION: · 24 unmodified lines
475	tcb_desc->bRTSBW = false;	474	tcb_desc->bRTSBW = false;
476	}	475	}
477		476
478
479	static void rtllib_txrate_selectmode(struct rtllib_device *ieee,	477	static void rtllib_txrate_selectmode(struct rtllib_device *ieee,
480	struct cb_desc *tcb_desc)	478	struct cb_desc *tcb_desc)
481	{	479	{
482	if (ieee->bTxDisableRateFallBack)	480	if (ieee->tx_dis_rate_fallback)
483	tcb_desc->bTxDisableRateFallBack = true;	481	tcb_desc->tx_dis_rate_fallback = true;
484		482
485	if (ieee->bTxUseDriverAssingedRate)	483	if (ieee->tx_use_drv_assinged_rate)
486	tcb_desc->bTxUseDriverAssingedRate = true;	484	tcb_desc->tx_use_drv_assinged_rate = true;
487	if (!tcb_desc->bTxDisableRateFallBack \|\|	485	if (!tcb_desc->tx_dis_rate_fallback \|\|
488	!tcb_desc->bTxUseDriverAssingedRate) {	486	!tcb_desc->tx_use_drv_assinged_rate) {
489	if (ieee->iw_mode == IW_MODE_INFRA \|\|	487	if (ieee->iw_mode == IW_MODE_INFRA \|\|
490	ieee->iw_mode == IW_MODE_ADHOC)	488	ieee->iw_mode == IW_MODE_ADHOC)
491	tcb_desc->RATRIndex = 0;	489	tcb_desc->RATRIndex = 0;
@@ -503,10 +501,10 @@ static u16 rtllib_query_seqnum(struct rtllib_device ieee, struct sk_buff skb, · 11 unmodified lines
503	struct tx_ts_record *pTS = NULL;	501	struct tx_ts_record *pTS = NULL;
504		502
505	if (!GetTs(ieee, (struct ts_common_info **)(&pTS), dst,	503	if (!GetTs(ieee, (struct ts_common_info **)(&pTS), dst,
506	skb->priority, TX_DIR, true))	504	skb->priority, TX_DIR, true))
507	return 0;	505	return 0;
508	seqnum = pTS->TxCurSeq;	506	seqnum = pTS->TxCurSeq;
509	pTS->TxCurSeq = (pTS->TxCurSeq+1)%4096;	507	pTS->TxCurSeq = (pTS->TxCurSeq + 1) % 4096;
510	return seqnum;	508	return seqnum;
511	}	509	}
512	return 0;	510	return 0;
@@ -582,7 +580,6 @@ static int rtllib_xmit_inter(struct sk_buff skb, struct net_device dev) · 69 unmodified lines
582	goto success;	580	goto success;
583	}	581	}
584		582
585
586	if (likely(ieee->raw_tx == 0)) {	583	if (likely(ieee->raw_tx == 0)) {
587	if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {	584	if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
588	netdev_warn(ieee->dev, "skb too small (%d).\n",	585	netdev_warn(ieee->dev, "skb too small (%d).\n",
@@ -614,14 +611,14 @@ static int rtllib_xmit_inter(struct sk_buff skb, struct net_device dev) · 25 unmodified lines
614	if (skb->len > 282) {	611	if (skb->len > 282) {
615	if (ether_type == ETH_P_IP) {	612	if (ether_type == ETH_P_IP) {
616	const struct iphdr ip = (struct iphdr )	613	const struct iphdr ip = (struct iphdr )
617	((u8 *)skb->data+14);	614	((u8 *)skb->data + 14);
618	if (ip->protocol == IPPROTO_UDP) {	615	if (ip->protocol == IPPROTO_UDP) {
619	struct udphdr *udp;	616	struct udphdr *udp;
620		617
621	udp = (struct udphdr )((u8 )ip +	618	udp = (struct udphdr )((u8 )ip +
622	(ip->ihl << 2));	619	(ip->ihl << 2));
623	if (((((u8 *)udp)[1] == 68) &&	620	if (((((u8 *)udp)[1] == 68) &&
624	(((u8 *)udp)[3] == 67)) \|\|	621	(((u8 *)udp)[3] == 67)) \|\|
625	((((u8 *)udp)[1] == 67) &&	622	((((u8 *)udp)[1] == 67) &&
626	(((u8 *)udp)[3] == 68))) {	623	(((u8 *)udp)[3] == 68))) {
627	bdhcp = true;	624	bdhcp = true;
@@ -715,11 +712,11 @@ static int rtllib_xmit_inter(struct sk_buff skb, struct net_device dev) · 87 unmodified lines
715	/* in case we are a client verify acm is not set for this ac */	712	/* in case we are a client verify acm is not set for this ac */
716	while (unlikely(ieee->wmm_acm & (0x01 << skb->priority))) {	713	while (unlikely(ieee->wmm_acm & (0x01 << skb->priority))) {
717	netdev_info(ieee->dev, "skb->priority = %x\n",	714	netdev_info(ieee->dev, "skb->priority = %x\n",
718	skb->priority);	715	skb->priority);
719	if (wme_downgrade_ac(skb))	716	if (wme_downgrade_ac(skb))
720	break;	717	break;
721	netdev_info(ieee->dev, "converted skb->priority = %x\n",	718	netdev_info(ieee->dev, "converted skb->priority = %x\n",
722	skb->priority);	719	skb->priority);
723	}	720	}
724		721
725	qos_ctl \|= skb->priority;	722	qos_ctl \|= skb->priority;
@@ -805,8 +802,8 @@ static int rtllib_xmit_inter(struct sk_buff skb, struct net_device dev) · 79 unmodified lines
805	* MOREFRAGS bit to the frame control	802	* MOREFRAGS bit to the frame control
806	*/	803	*/
807	if (i != nr_frags - 1) {	804	if (i != nr_frags - 1) {
808	frag_hdr->frame_ctl = cpu_to_le16(	805	frag_hdr->frame_ctl = cpu_to_le16(fc \|
809	fc \| RTLLIB_FCTL_MOREFRAGS);	806	RTLLIB_FCTL_MOREFRAGS);
810	bytes = bytes_per_frag;	807	bytes = bytes_per_frag;
811		808
812	} else {	809	} else {
@@ -816,18 +813,18 @@ static int rtllib_xmit_inter(struct sk_buff skb, struct net_device dev) · 3 unmodified lines
816	if ((qos_activated) && (!bIsMulticast)) {	813	if ((qos_activated) && (!bIsMulticast)) {
817	frag_hdr->seq_ctl =	814	frag_hdr->seq_ctl =
818	cpu_to_le16(rtllib_query_seqnum(ieee, skb_frag,	815	cpu_to_le16(rtllib_query_seqnum(ieee, skb_frag,
819	header.addr1));	816	header.addr1));
820	frag_hdr->seq_ctl =	817	frag_hdr->seq_ctl =
821	cpu_to_le16(le16_to_cpu(frag_hdr->seq_ctl)<<4 \| i);	818	cpu_to_le16(le16_to_cpu(frag_hdr->seq_ctl) << 4 \| i);
822	} else {	819	} else {
823	frag_hdr->seq_ctl =	820	frag_hdr->seq_ctl =
824	cpu_to_le16(ieee->seq_ctrl[0]<<4 \| i);	821	cpu_to_le16(ieee->seq_ctrl[0] << 4 \| i);
825	}	822	}
826	/* Put a SNAP header on the first fragment */	823	/* Put a SNAP header on the first fragment */
827	if (i == 0) {	824	if (i == 0) {
828	rtllib_put_snap(	825	rtllib_put_snap(skb_put(skb_frag,
829	skb_put(skb_frag, SNAP_SIZE +	826	SNAP_SIZE +
830	sizeof(u16)), ether_type);	827	sizeof(u16)), ether_type);
831	bytes -= SNAP_SIZE + sizeof(u16);	828	bytes -= SNAP_SIZE + sizeof(u16);
832	}	829	}
833		830
@@ -885,19 +882,18 @@ static int rtllib_xmit_inter(struct sk_buff skb, struct net_device dev) · 51 unmodified lines
885	tcb_desc->priority = skb->priority;	882	tcb_desc->priority = skb->priority;
886		883
887	if (ether_type == ETH_P_PAE) {	884	if (ether_type == ETH_P_PAE) {
888	if (ieee->pHTInfo->iot_action &	885	if (ieee->ht_info->iot_action &
889	HT_IOT_ACT_WA_IOT_Broadcom) {	886	HT_IOT_ACT_WA_IOT_Broadcom) {
890	tcb_desc->data_rate =	887	tcb_desc->data_rate =
891	MgntQuery_TxRateExcludeCCKRates(ieee);	888	MgntQuery_TxRateExcludeCCKRates(ieee);
892	tcb_desc->bTxDisableRateFallBack = false;	889	tcb_desc->tx_dis_rate_fallback = false;
893	} else {	890	} else {
894	tcb_desc->data_rate = ieee->basic_rate;	891	tcb_desc->data_rate = ieee->basic_rate;
895	tcb_desc->bTxDisableRateFallBack = 1;	892	tcb_desc->tx_dis_rate_fallback = 1;
896	}	893	}
897		894
898
899	tcb_desc->RATRIndex = 7;	895	tcb_desc->RATRIndex = 7;
900	tcb_desc->bTxUseDriverAssingedRate = 1;	896	tcb_desc->tx_use_drv_assinged_rate = 1;
901	} else {	897	} else {
902	if (is_multicast_ether_addr(header.addr1))	898	if (is_multicast_ether_addr(header.addr1))
903	tcb_desc->bMulticast = 1;	899	tcb_desc->bMulticast = 1;
@@ -910,19 +906,18 @@ static int rtllib_xmit_inter(struct sk_buff skb, struct net_device dev) · 6 unmodified lines
910	tcb_desc->data_rate = rtllib_current_rate(ieee);	906	tcb_desc->data_rate = rtllib_current_rate(ieee);
911		907
912	if (bdhcp) {	908	if (bdhcp) {
913	if (ieee->pHTInfo->iot_action &	909	if (ieee->ht_info->iot_action &
914	HT_IOT_ACT_WA_IOT_Broadcom) {	910	HT_IOT_ACT_WA_IOT_Broadcom) {
915	tcb_desc->data_rate =	911	tcb_desc->data_rate =
916	MgntQuery_TxRateExcludeCCKRates(ieee);	912	MgntQuery_TxRateExcludeCCKRates(ieee);
917	tcb_desc->bTxDisableRateFallBack = false;	913	tcb_desc->tx_dis_rate_fallback = false;
918	} else {	914	} else {
919	tcb_desc->data_rate = MGN_1M;	915	tcb_desc->data_rate = MGN_1M;
920	tcb_desc->bTxDisableRateFallBack = 1;	916	tcb_desc->tx_dis_rate_fallback = 1;
921	}	917	}
922		918
923
924	tcb_desc->RATRIndex = 7;	919	tcb_desc->RATRIndex = 7;
925	tcb_desc->bTxUseDriverAssingedRate = 1;	920	tcb_desc->tx_use_drv_assinged_rate = 1;
926	tcb_desc->bdhcp = 1;	921	tcb_desc->bdhcp = 1;
927	}	922	}
928		923
@@ -959,7 +954,6 @@ static int rtllib_xmit_inter(struct sk_buff skb, struct net_device dev) · 30 unmodified lines
959	netif_stop_queue(dev);	954	netif_stop_queue(dev);
960	stats->tx_errors++;	955	stats->tx_errors++;
961	return 1;	956	return 1;
962
963	}	957	}
964		958
965	netdev_tx_t rtllib_xmit(struct sk_buff skb, struct net_device dev)	959	netdev_tx_t rtllib_xmit(struct sk_buff skb, struct net_device dev)

drivers/staging/rtl8192e/rtllib_wx.c+3−3

@@ -217,7 +217,7 @@ static inline char rtl819x_translate_scan(struct rtllib_device ieee, · 216 unmodified lines
217	p = custom;	217	p = custom;
218	p += scnprintf(p, MAX_CUSTOM_LEN - (p - custom),	218	p += scnprintf(p, MAX_CUSTOM_LEN - (p - custom),
219	" Last beacon: %lums ago",	219	" Last beacon: %lums ago",
220	(jiffies - network->last_scanned) / (HZ / 100));	220	(100 * (jiffies - network->last_scanned)) / HZ);
221	iwe.u.data.length = p - custom;	221	iwe.u.data.length = p - custom;
222	if (iwe.u.data.length)	222	if (iwe.u.data.length)
223	start = iwe_stream_add_point_rsl(info, start, stop,	223	start = iwe_stream_add_point_rsl(info, start, stop,
@@ -258,8 +258,8 @@ int rtllib_wx_get_scan(struct rtllib_device *ieee, · 34 unmodified lines
258	escape_essid(network->ssid,	258	escape_essid(network->ssid,
259	network->ssid_len),	259	network->ssid_len),
260	network->bssid,	260	network->bssid,
261	(jiffies - network->last_scanned) /	261	(100 * (jiffies - network->last_scanned)) /
262	(HZ / 100));	262	HZ);
263	}	263	}
264		264
265	spin_unlock_irqrestore(&ieee->lock, flags);	265	spin_unlock_irqrestore(&ieee->lock, flags);

drivers/staging/rtl8192u/TODO+16−0

@@ -0,0 +1,16 @@
	1	To-do list:
	2
	3	* Correct the coding style according to Linux guidelines; please read the document
	4	at https://www.kernel.org/doc/html/latest/process/coding-style.html.
	5	* Remove unnecessary debugging/printing macros; for those that are still needed
	6	use the proper kernel API (pr_debug(), dev_dbg(), netdev_dbg()).
	7	* Remove dead code such as unusued functions, variables, fields, etc..
	8	* Use in-kernel API and remove unnecessary wrappers where possible.
	9	* Fix bugs due to code that sleeps in atomic context.
	10	* Remove the HAL layer and migrate its functionality into the relevant parts of
	11	the driver.
	12	* Switch to use LIB80211.
	13	* Switch to use MAC80211.
	14	* Switch to use CFG80211.
	15	* Improve the error handling of various functions, particularly those that use
	16	existing kernel APIs.

drivers/staging/rtl8192u/ieee80211/ieee80211.h+0−64

@@ -223,73 +223,10 @@ struct cb_desc { · 222 unmodified lines
223	#define MAX_IE_LEN 0xff	223	#define MAX_IE_LEN 0xff
224		224
225	// added for kernel conflict	225	// added for kernel conflict
226	#define ieee80211_crypt_deinit_entries ieee80211_crypt_deinit_entries_rsl
227	#define ieee80211_crypt_deinit_handler ieee80211_crypt_deinit_handler_rsl
228	#define ieee80211_crypt_delayed_deinit ieee80211_crypt_delayed_deinit_rsl
229	#define ieee80211_register_crypto_ops ieee80211_register_crypto_ops_rsl
230	#define ieee80211_unregister_crypto_ops ieee80211_unregister_crypto_ops_rsl
231	#define ieee80211_get_crypto_ops ieee80211_get_crypto_ops_rsl
232
233	#define ieee80211_ccmp_null ieee80211_ccmp_null_rsl
234
235	#define ieee80211_tkip_null ieee80211_tkip_null_rsl
236
237	#define free_ieee80211 free_ieee80211_rsl
238	#define alloc_ieee80211 alloc_ieee80211_rsl
239
240	#define ieee80211_rx ieee80211_rx_rsl
241	#define ieee80211_rx_mgt ieee80211_rx_mgt_rsl
242
243	#define ieee80211_get_beacon ieee80211_get_beacon_rsl
244	#define ieee80211_wake_queue ieee80211_wake_queue_rsl	226	#define ieee80211_wake_queue ieee80211_wake_queue_rsl
245	#define ieee80211_stop_queue ieee80211_stop_queue_rsl	227	#define ieee80211_stop_queue ieee80211_stop_queue_rsl
246	#define ieee80211_reset_queue ieee80211_reset_queue_rsl
247	#define ieee80211_softmac_stop_protocol ieee80211_softmac_stop_protocol_rsl
248	#define ieee80211_softmac_start_protocol ieee80211_softmac_start_protocol_rsl
249	#define ieee80211_is_shortslot ieee80211_is_shortslot_rsl
250	#define ieee80211_is_54g ieee80211_is_54g_rsl
251	#define ieee80211_wpa_supplicant_ioctl ieee80211_wpa_supplicant_ioctl_rsl
252	#define ieee80211_ps_tx_ack ieee80211_ps_tx_ack_rsl
253	#define ieee80211_softmac_xmit ieee80211_softmac_xmit_rsl
254	#define ieee80211_stop_send_beacons ieee80211_stop_send_beacons_rsl
255	#define notify_wx_assoc_event notify_wx_assoc_event_rsl	228	#define notify_wx_assoc_event notify_wx_assoc_event_rsl
256	#define SendDisassociation SendDisassociation_rsl	229	#define SendDisassociation SendDisassociation_rsl
257	#define ieee80211_disassociate ieee80211_disassociate_rsl
258	#define ieee80211_start_send_beacons ieee80211_start_send_beacons_rsl
259	#define ieee80211_stop_scan ieee80211_stop_scan_rsl
260	#define ieee80211_send_probe_requests ieee80211_send_probe_requests_rsl
261	#define ieee80211_softmac_scan_syncro ieee80211_softmac_scan_syncro_rsl
262	#define ieee80211_start_scan_syncro ieee80211_start_scan_syncro_rsl
263
264	#define ieee80211_wx_get_essid ieee80211_wx_get_essid_rsl
265	#define ieee80211_wx_set_essid ieee80211_wx_set_essid_rsl
266	#define ieee80211_wx_set_rate ieee80211_wx_set_rate_rsl
267	#define ieee80211_wx_get_rate ieee80211_wx_get_rate_rsl
268	#define ieee80211_wx_set_wap ieee80211_wx_set_wap_rsl
269	#define ieee80211_wx_get_wap ieee80211_wx_get_wap_rsl
270	#define ieee80211_wx_set_mode ieee80211_wx_set_mode_rsl
271	#define ieee80211_wx_get_mode ieee80211_wx_get_mode_rsl
272	#define ieee80211_wx_set_scan ieee80211_wx_set_scan_rsl
273	#define ieee80211_wx_get_freq ieee80211_wx_get_freq_rsl
274	#define ieee80211_wx_set_freq ieee80211_wx_set_freq_rsl
275	#define ieee80211_wx_set_rawtx ieee80211_wx_set_rawtx_rsl
276	#define ieee80211_wx_get_name ieee80211_wx_get_name_rsl
277	#define ieee80211_wx_set_power ieee80211_wx_set_power_rsl
278	#define ieee80211_wx_get_power ieee80211_wx_get_power_rsl
279	#define ieee80211_wlan_frequencies ieee80211_wlan_frequencies_rsl
280	#define ieee80211_wx_set_rts ieee80211_wx_set_rts_rsl
281	#define ieee80211_wx_get_rts ieee80211_wx_get_rts_rsl
282
283	#define ieee80211_txb_free ieee80211_txb_free_rsl
284
285	#define ieee80211_wx_set_gen_ie ieee80211_wx_set_gen_ie_rsl
286	#define ieee80211_wx_get_scan ieee80211_wx_get_scan_rsl
287	#define ieee80211_wx_set_encode ieee80211_wx_set_encode_rsl
288	#define ieee80211_wx_get_encode ieee80211_wx_get_encode_rsl
289	#define ieee80211_wx_set_mlme ieee80211_wx_set_mlme_rsl
290	#define ieee80211_wx_set_auth ieee80211_wx_set_auth_rsl
291	#define ieee80211_wx_set_encode_ext ieee80211_wx_set_encode_ext_rsl
292	#define ieee80211_wx_get_encode_ext ieee80211_wx_get_encode_ext_rsl
293		230
294		231
295	struct ieee_param {	232	struct ieee_param {
@@ -2256,7 +2193,6 @@ void ieee80211_ps_tx_ack(struct ieee80211_device *ieee, short success); · 1960 unmodified lines
2256	void softmac_mgmt_xmit(struct sk_buff skb, struct ieee80211_device ieee);	2193	void softmac_mgmt_xmit(struct sk_buff skb, struct ieee80211_device ieee);
2257		2194
2258	/* ieee80211_crypt_ccmp&tkip&wep.c */	2195	/* ieee80211_crypt_ccmp&tkip&wep.c */
2259	void ieee80211_tkip_null(void);
2260		2196
2261	int ieee80211_crypto_init(void);	2197	int ieee80211_crypto_init(void);
2262	void ieee80211_crypto_deinit(void);	2198	void ieee80211_crypto_deinit(void);

drivers/staging/rtl8192u/ieee80211/ieee80211_crypt_tkip.c+0−6

@@ -716,9 +716,3 @@ void ieee80211_crypto_tkip_exit(void) · 715 unmodified lines
716	{	716	{
717	ieee80211_unregister_crypto_ops(&ieee80211_crypt_tkip);	717	ieee80211_unregister_crypto_ops(&ieee80211_crypt_tkip);
718	}	718	}
719
720	void ieee80211_tkip_null(void)
721	{
722	// printk("============>%s()\n", __func__);
723	return;
724	}

drivers/staging/rtl8192u/ieee80211/ieee80211_module.c+0−3

@@ -159,9 +159,6 @@ struct net_device *alloc_ieee80211(int sizeof_priv) · 158 unmodified lines
159	ieee->last_packet_time[i] = 0;	159	ieee->last_packet_time[i] = 0;
160	}	160	}
161		161
162	/* These function were added to load crypte module autoly */
163	ieee80211_tkip_null();
164
165	return dev;	162	return dev;
166		163
167	failed:	164	failed:

drivers/staging/rtl8192u/ieee80211/ieee80211_rx.c+4−2

 #endif
 	if (ieee->iw_mode == IW_MODE_MONITOR) {
+		unsigned int len = skb->len;
 		ieee80211_monitor_rx(ieee, skb, rx_stats);
 		stats->rx_packets++;
-		stats->rx_bytes += skb->len;
+		stats->rx_bytes += len;
 		return 1;
 	}
 				info_element->data[0] == 0x00 &&
 				info_element->data[1] == 0x13 &&
 				info_element->data[2] == 0x74)) {
-				netdev_dbg(ieee->dev, "========> athros AP is exist\n");
+				netdev_dbg(ieee->dev, "========> Atheros AP exists\n");
 				network->atheros_cap_exist = true;
 			} else
 				network->atheros_cap_exist = false;

drivers/staging/rtl8712/os_intfs.c+22−5

 	padapter->cmdpriv.padapter = padapter;
 	ret = r8712_init_evt_priv(&padapter->evtpriv);
 	if (ret)
-		return ret;
+		goto free_cmd;
 	ret = r8712_init_mlme_priv(padapter);
 	if (ret)
-		return ret;
+		goto free_evt;
-	_r8712_init_xmit_priv(&padapter->xmitpriv, padapter);
+	ret = _r8712_init_xmit_priv(&padapter->xmitpriv, padapter);
-	_r8712_init_recv_priv(&padapter->recvpriv, padapter);
+	if (ret)
+		goto free_mlme;
+	ret = _r8712_init_recv_priv(&padapter->recvpriv, padapter);
+	if (ret)
+		goto free_xmit;
 	memset((unsigned char *)&padapter->securitypriv, 0,
 	       sizeof(struct security_priv));
 	timer_setup(&padapter->securitypriv.tkip_timer,
 		    r8712_use_tkipkey_handler, 0);
 	ret = _r8712_init_sta_priv(&padapter->stapriv);
 	if (ret)
-		return ret;
+		goto free_recv;
 	padapter->stapriv.padapter = padapter;
 	r8712_init_bcmc_stainfo(padapter);
 	r8712_init_pwrctrl_priv(padapter);
 	mp871xinit(padapter);
 	init_default_value(padapter);
 	r8712_InitSwLeds(padapter);
+	return 0;
+free_recv:
+	_r8712_free_recv_priv(&padapter->recvpriv);
+free_xmit:
+	_free_xmit_priv(&padapter->xmitpriv);
+free_mlme:
+	r8712_free_mlme_priv(&padapter->mlmepriv);
+free_evt:
+	r8712_free_evt_priv(&padapter->evtpriv);
+free_cmd:
+	r8712_free_cmd_priv(&padapter->cmdpriv);
 	return ret;
 }

drivers/staging/rtl8712/recv_osdep.h+4−4

drivers/staging/rtl8712/rtl8712_recv.c+4−3

 static void recv_tasklet(struct tasklet_struct *t);
-void r8712_init_recv_priv(struct recv_priv *precvpriv,
+int r8712_init_recv_priv(struct recv_priv *precvpriv,
-			  struct _adapter *padapter)
+			 struct _adapter *padapter)
 {
 	int i;
 	struct recv_buf *precvbuf;
 	precvpriv->pallocated_recv_buf =
 		kzalloc(NR_RECVBUFF * sizeof(struct recv_buf) + 4, GFP_ATOMIC);
 	if (!precvpriv->pallocated_recv_buf)
-		return;
+		return -ENOMEM;
 	precvpriv->precv_buf = precvpriv->pallocated_recv_buf + 4 -
 			      ((addr_t)(precvpriv->pallocated_recv_buf) & 3);
 	precvbuf = (struct recv_buf *)precvpriv->precv_buf;
 		}
 		pskb = NULL;
 	}
+	return 0;
 }
 void r8712_free_recv_priv(struct recv_priv *precvpriv)

drivers/staging/rtl8712/rtl8712_xmit.c+1−2

 #ifdef CONFIG_R8712_TX_AGGR
 	struct xmit_frame *p2ndxmitframe = NULL;
 #else
-	int res = _SUCCESS, xcnt = 0;
+	int res = _SUCCESS;
 #endif
 	phwxmits = pxmitpriv->hwxmits;
 			dump_xframe(padapter, pxmitframe);
 		else
 			r8712_free_xmitframe_ex(pxmitpriv, pxmitframe);
-		xcnt++;
 #endif
 	} else { /* pxmitframe == NULL && p2ndxmitframe == NULL */

drivers/staging/rtl8712/rtl871x_recv.c+9−7

 #define _RTL871X_RECV_C_
 #include <linux/ip.h>
-#include <linux/slab.h>
 #include <linux/if_ether.h>
-#include <linux/kmemleak.h>
 #include <linux/etherdevice.h>
 #include <linux/ieee80211.h>
 #include <net/cfg80211.h>
 	_init_queue(&psta_recvpriv->defrag_q);
 }
-void _r8712_init_recv_priv(struct recv_priv *precvpriv,
+int _r8712_init_recv_priv(struct recv_priv *precvpriv,
-			   struct _adapter *padapter)
+			  struct _adapter *padapter)
 {
+	int ret;
 	sint i;
 	union recv_frame *precvframe;
 				sizeof(union recv_frame) + RXFRAME_ALIGN_SZ,
 				GFP_ATOMIC);
 	if (!precvpriv->pallocated_frame_buf)
-		return;
+		return -ENOMEM;
-	kmemleak_not_leak(precvpriv->pallocated_frame_buf);
 	precvpriv->precv_frame_buf = precvpriv->pallocated_frame_buf +
 				    RXFRAME_ALIGN_SZ -
 				    ((addr_t)(precvpriv->pallocated_frame_buf) &
 		precvframe++;
 	}
 	precvpriv->rx_pending_cnt = 1;
-	r8712_init_recv_priv(precvpriv, padapter);
+	ret = r8712_init_recv_priv(precvpriv, padapter);
+	if (ret)
+		kfree(precvpriv->pallocated_frame_buf);
+	return ret;
 }
 void _r8712_free_recv_priv(struct recv_priv *precvpriv)

drivers/staging/rtl8723bs/core/rtw_efuse.c+1−1

@@ -282,7 +282,7 @@ u8 efuse_OneByteWrite(struct adapter *padapter, u16 addr, u8 data, bool bPseudoT · 281 unmodified lines
282	{	282	{
283	u8 tmpidx = 0;	283	u8 tmpidx = 0;
284	u8 bResult = false;	284	u8 bResult = false;
285	u32 efuseValue = 0;	285	u32 efuseValue;
286		286
287	if (bPseudoTest)	287	if (bPseudoTest)
288	return Efuse_Write1ByteToFakeContent(addr, data);	288	return Efuse_Write1ByteToFakeContent(addr, data);

drivers/staging/rtl8723bs/core/rtw_ieee80211.c+6−6

@@ -1063,18 +1063,18 @@ void rtw_get_bcn_info(struct wlan_network *pnetwork) · 1062 unmodified lines
1063	/* parsing HT_CAP_IE */	1063	/* parsing HT_CAP_IE */
1064	p = rtw_get_ie(pnetwork->network.ies + _FIXED_IE_LENGTH_, WLAN_EID_HT_CAPABILITY, &len, pnetwork->network.ie_length - _FIXED_IE_LENGTH_);	1064	p = rtw_get_ie(pnetwork->network.ies + _FIXED_IE_LENGTH_, WLAN_EID_HT_CAPABILITY, &len, pnetwork->network.ie_length - _FIXED_IE_LENGTH_);
1065	if (p && len > 0) {	1065	if (p && len > 0) {
1066	pht_cap = (struct ieee80211_ht_cap *)(p + 2);	1066	pht_cap = (struct ieee80211_ht_cap *)(p + 2);
1067	pnetwork->bcn_info.ht_cap_info = le16_to_cpu(pht_cap->cap_info);	1067	pnetwork->bcn_info.ht_cap_info = le16_to_cpu(pht_cap->cap_info);
1068	} else {	1068	} else {
1069	pnetwork->bcn_info.ht_cap_info = 0;	1069	pnetwork->bcn_info.ht_cap_info = 0;
1070	}	1070	}
1071	/* parsing HT_INFO_IE */	1071	/* parsing HT_INFO_IE */
1072	p = rtw_get_ie(pnetwork->network.ies + _FIXED_IE_LENGTH_, WLAN_EID_HT_OPERATION, &len, pnetwork->network.ie_length - _FIXED_IE_LENGTH_);	1072	p = rtw_get_ie(pnetwork->network.ies + _FIXED_IE_LENGTH_, WLAN_EID_HT_OPERATION, &len, pnetwork->network.ie_length - _FIXED_IE_LENGTH_);
1073	if (p && len > 0) {	1073	if (p && len > 0) {
1074	pht_info = (struct HT_info_element *)(p + 2);	1074	pht_info = (struct HT_info_element *)(p + 2);
1075	pnetwork->bcn_info.ht_info_infos_0 = pht_info->infos[0];	1075	pnetwork->bcn_info.ht_info_infos_0 = pht_info->infos[0];
1076	} else {	1076	} else {
1077	pnetwork->bcn_info.ht_info_infos_0 = 0;	1077	pnetwork->bcn_info.ht_info_infos_0 = 0;
1078	}	1078	}
1079	}	1079	}
1080		1080

drivers/staging/rtl8723bs/core/rtw_ioctl_set.c+9−8

@@ -78,6 +78,7 @@ u8 rtw_do_join(struct adapter *padapter) · 77 unmodified lines
78	goto exit;	78	goto exit;
79	} else {	79	} else {
80	int select_ret;	80	int select_ret;
		81
81	spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));	82	spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
82	select_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv);	83	select_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv);
83	if (select_ret == _SUCCESS) {	84	if (select_ret == _SUCCESS) {
@@ -159,7 +160,7 @@ u8 rtw_set_802_11_ssid(struct adapter padapter, struct ndis_802_11_ssid ssid) · 75 unmodified lines
159	if (check_fwstate(pmlmepriv, _FW_LINKED\|WIFI_ADHOC_MASTER_STATE) == true) {	160	if (check_fwstate(pmlmepriv, _FW_LINKED\|WIFI_ADHOC_MASTER_STATE) == true) {
160	if ((pmlmepriv->assoc_ssid.ssid_length == ssid->ssid_length) &&	161	if ((pmlmepriv->assoc_ssid.ssid_length == ssid->ssid_length) &&
161	(!memcmp(&pmlmepriv->assoc_ssid.ssid, ssid->ssid, ssid->ssid_length))) {	162	(!memcmp(&pmlmepriv->assoc_ssid.ssid, ssid->ssid, ssid->ssid_length))) {
162	if ((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == false)) {	163	if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == false) {
163	if (rtw_is_same_ibss(padapter, pnetwork) == false) {	164	if (rtw_is_same_ibss(padapter, pnetwork) == false) {
164	/* if in WIFI_ADHOC_MASTER_STATE \| WIFI_ADHOC_STATE, create bss or rejoin again */	165	/* if in WIFI_ADHOC_MASTER_STATE \| WIFI_ADHOC_STATE, create bss or rejoin again */
165	rtw_disassoc_cmd(padapter, 0, true);	166	rtw_disassoc_cmd(padapter, 0, true);
@@ -311,7 +312,7 @@ u8 rtw_set_802_11_infrastructure_mode(struct adapter *padapter, · 145 unmodified lines
311	if ((pold_state == Ndis802_11Infrastructure) \|\| (pold_state == Ndis802_11IBSS)) {	312	if ((pold_state == Ndis802_11Infrastructure) \|\| (pold_state == Ndis802_11IBSS)) {
312	if (check_fwstate(pmlmepriv, _FW_LINKED) == true)	313	if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
313	rtw_indicate_disconnect(padapter); /* will clr Linked_state; before this function, we must have checked whether issue dis-assoc_cmd or not */	314	rtw_indicate_disconnect(padapter); /* will clr Linked_state; before this function, we must have checked whether issue dis-assoc_cmd or not */
314	}	315	}
315		316
316	*pold_state = networktype;	317	*pold_state = networktype;
317		318
@@ -367,7 +368,7 @@ u8 rtw_set_802_11_disassociate(struct adapter *padapter) · 49 unmodified lines
367		368
368	u8 rtw_set_802_11_bssid_list_scan(struct adapter padapter, struct ndis_802_11_ssid pssid, int ssid_max_num)	369	u8 rtw_set_802_11_bssid_list_scan(struct adapter padapter, struct ndis_802_11_ssid pssid, int ssid_max_num)
369	{	370	{
370	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;	371	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
371	u8 res = true;	372	u8 res = true;
372		373
373	if (!padapter) {	374	if (!padapter) {
@@ -462,11 +463,11 @@ exit: · 88 unmodified lines
462	}	463	}
463		464
464	/*	465	/*
465	* rtw_get_cur_max_rate -	466	* rtw_get_cur_max_rate -
466	* @adapter: pointer to struct adapter structure	467	* @adapter: pointer to struct adapter structure
467	*	468	*
468	* Return 0 or 100Kbps	469	* Return 0 or 100Kbps
469	*/	470	*/
470	u16 rtw_get_cur_max_rate(struct adapter *adapter)	471	u16 rtw_get_cur_max_rate(struct adapter *adapter)
471	{	472	{
472	int i = 0;	473	int i = 0;

drivers/staging/rtl8723bs/core/rtw_mlme.c+14−16

@@ -389,7 +389,7 @@ int is_same_network(struct wlan_bssid_ex src, struct wlan_bssid_ex dst, u8 fea · 388 unmodified lines
389	__le16 tmps, tmpd;	389	__le16 tmps, tmpd;
390		390
391	if (rtw_bug_check(dst, src, &s_cap, &d_cap) == false)	391	if (rtw_bug_check(dst, src, &s_cap, &d_cap) == false)
392	return false;	392	return false;
393		393
394	memcpy((u8 *)&tmps, rtw_get_capability_from_ie(src->ies), 2);	394	memcpy((u8 *)&tmps, rtw_get_capability_from_ie(src->ies), 2);
395	memcpy((u8 *)&tmpd, rtw_get_capability_from_ie(dst->ies), 2);	395	memcpy((u8 *)&tmpd, rtw_get_capability_from_ie(dst->ies), 2);
@@ -669,7 +669,7 @@ int rtw_is_desired_network(struct adapter adapter, struct wlan_network pnetwor · 273 unmodified lines
669	uint ie_len = 0;	669	uint ie_len = 0;
670		670
671	if ((desired_encmode == Ndis802_11EncryptionDisabled) && (privacy != 0))	671	if ((desired_encmode == Ndis802_11EncryptionDisabled) && (privacy != 0))
672	bselected = false;	672	bselected = false;
673		673
674	if (psecuritypriv->ndisauthtype == Ndis802_11AuthModeWPA2PSK) {	674	if (psecuritypriv->ndisauthtype == Ndis802_11AuthModeWPA2PSK) {
675	p = rtw_get_ie(pnetwork->network.ies + _BEACON_IE_OFFSET_, WLAN_EID_RSN, &ie_len, (pnetwork->network.ie_length - _BEACON_IE_OFFSET_));	675	p = rtw_get_ie(pnetwork->network.ies + _BEACON_IE_OFFSET_, WLAN_EID_RSN, &ie_len, (pnetwork->network.ie_length - _BEACON_IE_OFFSET_));
@@ -795,7 +795,7 @@ void rtw_surveydone_event_callback(struct adapter adapter, u8 pbuf) · 119 unmodified lines
795	pmlmepriv->to_join = false;	795	pmlmepriv->to_join = false;
796	s_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv);	796	s_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv);
797	if (s_ret == _SUCCESS) {	797	if (s_ret == _SUCCESS) {
798	_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);	798	_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);
799	} else if (s_ret == 2) {/* there is no need to wait for join */	799	} else if (s_ret == 2) {/* there is no need to wait for join */
800	_clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);	800	_clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
801	rtw_indicate_connect(adapter);	801	rtw_indicate_connect(adapter);
@@ -2010,8 +2010,8 @@ int rtw_restruct_wmm_ie(struct adapter adapter, u8 in_ie, u8 *out_ie, uint in_ · 1208 unmodified lines
2010		2010
2011	if (in_ie[i] == 0xDD && in_ie[i+2] == 0x00 && in_ie[i+3] == 0x50 && in_ie[i+4] == 0xF2 && in_ie[i+5] == 0x02 && i+5 < in_len) { /* WMM element ID and OUI */	2011	if (in_ie[i] == 0xDD && in_ie[i+2] == 0x00 && in_ie[i+3] == 0x50 && in_ie[i+4] == 0xF2 && in_ie[i+5] == 0x02 && i+5 < in_len) { /* WMM element ID and OUI */
2012	for (j = i; j < i + 9; j++) {	2012	for (j = i; j < i + 9; j++) {
2013	out_ie[ielength] = in_ie[j];	2013	out_ie[ielength] = in_ie[j];
2014	ielength++;	2014	ielength++;
2015	}	2015	}
2016	out_ie[initial_out_len + 1] = 0x07;	2016	out_ie[initial_out_len + 1] = 0x07;
2017	out_ie[initial_out_len + 6] = 0x00;	2017	out_ie[initial_out_len + 6] = 0x00;
@@ -2064,15 +2064,13 @@ static int rtw_append_pmkid(struct adapter Adapter, int iEntry, u8 ie, uint ie · 46 unmodified lines
2064		2064
2065	if (ie[13] <= 20) {	2065	if (ie[13] <= 20) {
2066	/* The RSN IE didn't include the PMK ID, append the PMK information */	2066	/* The RSN IE didn't include the PMK ID, append the PMK information */
2067	ie[ie_len] = 1;	2067	ie[ie_len] = 1;
2068	ie_len++;	2068	ie_len++;
2069	ie[ie_len] = 0; /* PMKID count = 0x0100 */	2069	ie[ie_len] = 0; /* PMKID count = 0x0100 */
2070	ie_len++;	2070	ie_len++;
2071	memcpy(&ie[ie_len], &psecuritypriv->PMKIDList[iEntry].PMKID, 16);	2071	memcpy(&ie[ie_len], &psecuritypriv->PMKIDList[iEntry].PMKID, 16);
2072		2072	ie_len += 16;
2073	ie_len += 16;	2073	ie[13] += 18;/* PMKID length = 2+16 */
2074	ie[13] += 18;/* PMKID length = 2+16 */
2075
2076	}	2074	}
2077	return ie_len;	2075	return ie_len;
2078	}	2076	}
@@ -2091,9 +2089,9 @@ signed int rtw_restruct_sec_ie(struct adapter adapter, u8 in_ie, u8 *out_ie, u · 12 unmodified lines
2091	memcpy(out_ie, in_ie, 12);	2089	memcpy(out_ie, in_ie, 12);
2092	ielength = 12;	2090	ielength = 12;
2093	if ((ndisauthmode == Ndis802_11AuthModeWPA) \|\| (ndisauthmode == Ndis802_11AuthModeWPAPSK))	2091	if ((ndisauthmode == Ndis802_11AuthModeWPA) \|\| (ndisauthmode == Ndis802_11AuthModeWPAPSK))
2094	authmode = WLAN_EID_VENDOR_SPECIFIC;	2092	authmode = WLAN_EID_VENDOR_SPECIFIC;
2095	if ((ndisauthmode == Ndis802_11AuthModeWPA2) \|\| (ndisauthmode == Ndis802_11AuthModeWPA2PSK))	2093	if ((ndisauthmode == Ndis802_11AuthModeWPA2) \|\| (ndisauthmode == Ndis802_11AuthModeWPA2PSK))
2096	authmode = WLAN_EID_RSN;	2094	authmode = WLAN_EID_RSN;
2097		2095
2098	if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {	2096	if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
2099	memcpy(out_ie+ielength, psecuritypriv->wps_ie, psecuritypriv->wps_ie_len);	2097	memcpy(out_ie+ielength, psecuritypriv->wps_ie, psecuritypriv->wps_ie_len);

drivers/staging/rtl8723bs/core/rtw_mlme_ext.c+1−1

@@ -5447,7 +5447,7 @@ u8 disconnect_hdl(struct adapter padapter, unsigned char pbuf) · 5446 unmodified lines
5447	u8 val8;	5447	u8 val8;
5448		5448
5449	if (is_client_associated_to_ap(padapter))	5449	if (is_client_associated_to_ap(padapter))
5450	issue_deauth_ex(padapter, pnetwork->mac_address, WLAN_REASON_DEAUTH_LEAVING, param->deauth_timeout_ms/100, 100);	5450	issue_deauth_ex(padapter, pnetwork->mac_address, WLAN_REASON_DEAUTH_LEAVING, param->deauth_timeout_ms/100, 100);
5451		5451
5452	if (((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) \|\| ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)) {	5452	if (((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) \|\| ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)) {
5453	/* Stop BCN */	5453	/* Stop BCN */

drivers/staging/rtl8723bs/core/rtw_recv.c+3−3

@@ -161,7 +161,7 @@ int rtw_free_recvframe(union recv_frame precvframe, struct __queue pfree_recv_ · 160 unmodified lines
161		161
162	if (padapter) {	162	if (padapter) {
163	if (pfree_recv_queue == &precvpriv->free_recv_queue)	163	if (pfree_recv_queue == &precvpriv->free_recv_queue)
164	precvpriv->free_recvframe_cnt++;	164	precvpriv->free_recvframe_cnt++;
165	}	165	}
166	spin_unlock_bh(&pfree_recv_queue->lock);	166	spin_unlock_bh(&pfree_recv_queue->lock);
167	return _SUCCESS;	167	return _SUCCESS;
@@ -691,8 +691,8 @@ static signed int sta2sta_data_frame(struct adapter adapter, union recv_frame · 523 unmodified lines
691	if (bmcast) {	691	if (bmcast) {
692	/* For AP mode, if DA == MCAST, then BSSID should be also MCAST */	692	/* For AP mode, if DA == MCAST, then BSSID should be also MCAST */
693	if (!IS_MCAST(pattrib->bssid)) {	693	if (!IS_MCAST(pattrib->bssid)) {
694	ret = _FAIL;	694	ret = _FAIL;
695	goto exit;	695	goto exit;
696	}	696	}
697	} else { /* not mc-frame */	697	} else { /* not mc-frame */
698	/* For AP mode, if DA is non-MCAST, then it must be BSSID, and bssid == BSSID */	698	/* For AP mode, if DA is non-MCAST, then it must be BSSID, and bssid == BSSID */

drivers/staging/rtl8723bs/core/rtw_sta_mgt.c+1−1

@@ -551,7 +551,7 @@ u8 rtw_access_ctrl(struct adapter padapter, u8 mac_addr) · 550 unmodified lines
551	else if (pacl_list->mode == 2)/* deny unless in accept list */	551	else if (pacl_list->mode == 2)/* deny unless in accept list */
552	res = match;	552	res = match;
553	else	553	else
554	res = true;	554	res = true;
555		555
556	return res;	556	return res;
557	}	557	}

drivers/staging/rtl8723bs/core/rtw_wlan_util.c+4−8

 			pmlmeinfo->HT_caps.u.HT_cap[i] &= (pIE->data[i]);
 		} else {
 			/* modify from  fw by Thomas 2010/11/17 */
-			if ((pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3) > (pIE->data[i] & 0x3))
+			max_AMPDU_len = min(pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3,
-				max_AMPDU_len = (pIE->data[i] & 0x3);
+					    pIE->data[i] & 0x3);
-			else
-				max_AMPDU_len = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3);
-			if ((pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) > (pIE->data[i] & 0x1c))
+			min_MPDU_spacing = max(pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c,
-				min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c);
+					       pIE->data[i] & 0x1c);
-			else
-				min_MPDU_spacing = (pIE->data[i] & 0x1c);
 			pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para = max_AMPDU_len | min_MPDU_spacing;
 		}

drivers/staging/rtl8723bs/hal/HalPhyRf_8723B.c+10−11

 			Final_CCK_Swing_Index = 0;
 		setIqkMatrix_8723B(pDM_Odm, Final_OFDM_Swing_Index, RFPath,
-			pDM_Odm->RFCalibrateInfo.IQKMatrixRegSetting[ChannelMappedIndex].Value[0][0],
+			pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][0],
-			pDM_Odm->RFCalibrateInfo.IQKMatrixRegSetting[ChannelMappedIndex].Value[0][1]);
+			pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][1]);
 		setCCKFilterCoefficient(pDM_Odm, Final_CCK_Swing_Index);
 			pDM_Odm->Remnant_OFDMSwingIdx[RFPath] = Final_OFDM_Swing_Index - PwrTrackingLimit_OFDM;
 			setIqkMatrix_8723B(pDM_Odm, PwrTrackingLimit_OFDM, RFPath,
-				pDM_Odm->RFCalibrateInfo.IQKMatrixRegSetting[ChannelMappedIndex].Value[0][0],
+				pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][0],
-				pDM_Odm->RFCalibrateInfo.IQKMatrixRegSetting[ChannelMappedIndex].Value[0][1]);
+				pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][1]);
 			pDM_Odm->Modify_TxAGC_Flag_PathA = true;
 			PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, OFDM);
 			pDM_Odm->Remnant_OFDMSwingIdx[RFPath] = Final_OFDM_Swing_Index;
 			setIqkMatrix_8723B(pDM_Odm, 0, RFPath,
-				pDM_Odm->RFCalibrateInfo.IQKMatrixRegSetting[ChannelMappedIndex].Value[0][0],
+				pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][0],
-				pDM_Odm->RFCalibrateInfo.IQKMatrixRegSetting[ChannelMappedIndex].Value[0][1]);
+				pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][1]);
 			pDM_Odm->Modify_TxAGC_Flag_PathA = true;
 			PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, OFDM);
 			PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, HT_MCS0_MCS7);
 		} else {
 			setIqkMatrix_8723B(pDM_Odm, Final_OFDM_Swing_Index, RFPath,
-				pDM_Odm->RFCalibrateInfo.IQKMatrixRegSetting[ChannelMappedIndex].Value[0][0],
+				pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][0],
-				pDM_Odm->RFCalibrateInfo.IQKMatrixRegSetting[ChannelMappedIndex].Value[0][1]);
+				pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][1]);
 			if (pDM_Odm->Modify_TxAGC_Flag_PathA) { /* If TxAGC has changed, reset TxAGC again */
 				pDM_Odm->Remnant_OFDMSwingIdx[RFPath] = 0;
 /* To Fix BSOD when final_candidate is 0xff */
 /* by sherry 20120321 */
 	if (final_candidate < 4) {
-		for (i = 0; i < IQK_Matrix_REG_NUM; i++)
+		for (i = 0; i < IQK_MATRIX_REG_NUM; i++)
-			pDM_Odm->RFCalibrateInfo.IQKMatrixRegSetting[0].Value[0][i] = result[final_candidate][i];
+			pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[0][i] = result[final_candidate][i];
-		pDM_Odm->RFCalibrateInfo.IQKMatrixRegSetting[0].bIQKDone = true;
 	}
 	_PHY_SaveADDARegisters8723B(padapter, IQK_BB_REG_92C, pDM_Odm->RFCalibrateInfo.IQK_BB_backup_recover, 9);

drivers/staging/rtl8723bs/hal/odm.h+3−9

 #define HP_THERMAL_NUM		8
 #define AVG_THERMAL_NUM		8
-#define IQK_Matrix_REG_NUM	8
+#define IQK_MATRIX_REG_NUM	8
-#define IQK_Matrix_Settings_NUM	14 /* Channels_2_4G_NUM */
+#define IQK_MATRIX_SETTINGS_NUM	14 /* Channels_2_4G_NUM */
 #define		DM_Type_ByFW			0
 #define		DM_Type_ByDriver		1
 	TYPE_ALNA3 = BIT(3)|BIT(2)|BIT(1)|BIT(0)
 };
-struct iqk_matrix_regs_setting { /* _IQK_MATRIX_REGS_SETTING */
-	bool bIQKDone;
-	s32 Value[3][IQK_Matrix_REG_NUM];
-	bool bBWIqkResultSaved[3];
-};
 /* Remove PATHDIV_PARA struct to odm_PathDiv.h */
 struct odm_rf_cal_t { /* ODM_RF_Calibration_Structure */
 	u8 ThermalValue_HP[HP_THERMAL_NUM];
 	u8 ThermalValue_HP_index;
-	struct iqk_matrix_regs_setting IQKMatrixRegSetting[IQK_Matrix_Settings_NUM];
+	s32 iqk_matrix_regs_setting_value[IQK_MATRIX_SETTINGS_NUM][IQK_MATRIX_REG_NUM];
 	bool bNeedIQK;
 	bool bIQKInProgress;
 	u8 Delta_IQK;

drivers/staging/rtl8723bs/hal/odm_DIG.c+1−4

 	/* Lower bound checking */
 	/* RSSI Lower bound check */
-	if ((pDM_Odm->RSSI_Min-10) > DM_DIG_MIN_NIC)
+	RSSI_Lower = max(pDM_Odm->RSSI_Min - 10, DM_DIG_MIN_NIC);
-		RSSI_Lower = pDM_Odm->RSSI_Min-10;
-	else
-		RSSI_Lower = DM_DIG_MIN_NIC;
 	/* Upper and Lower Bound checking */
 	if (CurrentIGI > DM_DIG_MAX_NIC)

drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c+1−1

@@ -1551,7 +1551,7 @@ static int rtw_cfg80211_set_wpa_ie(struct adapter padapter, u8 pie, size_t iel · 1550 unmodified lines
1551		1551
1552	wps_ie = rtw_get_wps_ie(buf, ielen, NULL, &wps_ielen);	1552	wps_ie = rtw_get_wps_ie(buf, ielen, NULL, &wps_ielen);
1553	if (wps_ie && wps_ielen > 0) {	1553	if (wps_ie && wps_ielen > 0) {
1554	padapter->securitypriv.wps_ie_len = wps_ielen < MAX_WPS_IE_LEN ? wps_ielen : MAX_WPS_IE_LEN;	1554	padapter->securitypriv.wps_ie_len = min_t(uint, wps_ielen, MAX_WPS_IE_LEN);
1555	memcpy(padapter->securitypriv.wps_ie, wps_ie, padapter->securitypriv.wps_ie_len);	1555	memcpy(padapter->securitypriv.wps_ie, wps_ie, padapter->securitypriv.wps_ie_len);
1556	set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS);	1556	set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS);
1557	} else {	1557	} else {

drivers/staging/rts5208/sd.c+2−1

 				if (CHK_SD(sd_card)) {
 					retval = reset_sd(chip);
 					if (retval != STATUS_SUCCESS) {
-						sd_card->sd_lock_status &= ~(SD_UNLOCK_POW_ON | SD_SDR_RST);
+						sd_card->sd_lock_status &=
+							~(SD_UNLOCK_POW_ON | SD_SDR_RST);
 						goto sd_execute_write_cmd_failed;
 					}
 				}

drivers/staging/sm750fb/Kconfig+1−1

@@ -9,7 +9,7 @@ config FB_SM750 · 8 unmodified lines
9	select VIDEO_NOMODESET	9	select VIDEO_NOMODESET
10	help	10	help
11	Frame buffer driver for the Silicon Motion SM750 chip	11	Frame buffer driver for the Silicon Motion SM750 chip
12	with 2D accelearion and dual head support.	12	with 2D acceleration and dual head support.
13		13
14	This driver is also available as a module. The module will be	14	This driver is also available as a module. The module will be
15	called sm750fb. If you want to compile it as a module, say M	15	called sm750fb. If you want to compile it as a module, say M

drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c+15−15

@@ -87,21 +87,21 @@ static struct mmal_fmt formats[] = { · 86 unmodified lines
87	.depth = 12,	87	.depth = 12,
88	.mmal_component = COMP_CAMERA,	88	.mmal_component = COMP_CAMERA,
89	.ybbp = 1,	89	.ybbp = 1,
90	.remove_padding = 1,	90	.remove_padding = true,
91	}, {	91	}, {
92	.fourcc = V4L2_PIX_FMT_YUYV,	92	.fourcc = V4L2_PIX_FMT_YUYV,
93	.mmal = MMAL_ENCODING_YUYV,	93	.mmal = MMAL_ENCODING_YUYV,
94	.depth = 16,	94	.depth = 16,
95	.mmal_component = COMP_CAMERA,	95	.mmal_component = COMP_CAMERA,
96	.ybbp = 2,	96	.ybbp = 2,
97	.remove_padding = 0,	97	.remove_padding = false,
98	}, {	98	}, {
99	.fourcc = V4L2_PIX_FMT_RGB24,	99	.fourcc = V4L2_PIX_FMT_RGB24,
100	.mmal = MMAL_ENCODING_RGB24,	100	.mmal = MMAL_ENCODING_RGB24,
101	.depth = 24,	101	.depth = 24,
102	.mmal_component = COMP_CAMERA,	102	.mmal_component = COMP_CAMERA,
103	.ybbp = 3,	103	.ybbp = 3,
104	.remove_padding = 0,	104	.remove_padding = false,
105	}, {	105	}, {
106	.fourcc = V4L2_PIX_FMT_JPEG,	106	.fourcc = V4L2_PIX_FMT_JPEG,
107	.flags = V4L2_FMT_FLAG_COMPRESSED,	107	.flags = V4L2_FMT_FLAG_COMPRESSED,
@@ -109,7 +109,7 @@ static struct mmal_fmt formats[] = { · 1 unmodified line
109	.depth = 8,	109	.depth = 8,
110	.mmal_component = COMP_IMAGE_ENCODE,	110	.mmal_component = COMP_IMAGE_ENCODE,
111	.ybbp = 0,	111	.ybbp = 0,
112	.remove_padding = 0,	112	.remove_padding = false,
113	}, {	113	}, {
114	.fourcc = V4L2_PIX_FMT_H264,	114	.fourcc = V4L2_PIX_FMT_H264,
115	.flags = V4L2_FMT_FLAG_COMPRESSED,	115	.flags = V4L2_FMT_FLAG_COMPRESSED,
@@ -117,7 +117,7 @@ static struct mmal_fmt formats[] = { · 1 unmodified line
117	.depth = 8,	117	.depth = 8,
118	.mmal_component = COMP_VIDEO_ENCODE,	118	.mmal_component = COMP_VIDEO_ENCODE,
119	.ybbp = 0,	119	.ybbp = 0,
120	.remove_padding = 0,	120	.remove_padding = false,
121	}, {	121	}, {
122	.fourcc = V4L2_PIX_FMT_MJPEG,	122	.fourcc = V4L2_PIX_FMT_MJPEG,
123	.flags = V4L2_FMT_FLAG_COMPRESSED,	123	.flags = V4L2_FMT_FLAG_COMPRESSED,
@@ -125,63 +125,63 @@ static struct mmal_fmt formats[] = { · 1 unmodified line
125	.depth = 8,	125	.depth = 8,
126	.mmal_component = COMP_VIDEO_ENCODE,	126	.mmal_component = COMP_VIDEO_ENCODE,
127	.ybbp = 0,	127	.ybbp = 0,
128	.remove_padding = 0,	128	.remove_padding = false,
129	}, {	129	}, {
130	.fourcc = V4L2_PIX_FMT_YVYU,	130	.fourcc = V4L2_PIX_FMT_YVYU,
131	.mmal = MMAL_ENCODING_YVYU,	131	.mmal = MMAL_ENCODING_YVYU,
132	.depth = 16,	132	.depth = 16,
133	.mmal_component = COMP_CAMERA,	133	.mmal_component = COMP_CAMERA,
134	.ybbp = 2,	134	.ybbp = 2,
135	.remove_padding = 0,	135	.remove_padding = false,
136	}, {	136	}, {
137	.fourcc = V4L2_PIX_FMT_VYUY,	137	.fourcc = V4L2_PIX_FMT_VYUY,
138	.mmal = MMAL_ENCODING_VYUY,	138	.mmal = MMAL_ENCODING_VYUY,
139	.depth = 16,	139	.depth = 16,
140	.mmal_component = COMP_CAMERA,	140	.mmal_component = COMP_CAMERA,
141	.ybbp = 2,	141	.ybbp = 2,
142	.remove_padding = 0,	142	.remove_padding = false,
143	}, {	143	}, {
144	.fourcc = V4L2_PIX_FMT_UYVY,	144	.fourcc = V4L2_PIX_FMT_UYVY,
145	.mmal = MMAL_ENCODING_UYVY,	145	.mmal = MMAL_ENCODING_UYVY,
146	.depth = 16,	146	.depth = 16,
147	.mmal_component = COMP_CAMERA,	147	.mmal_component = COMP_CAMERA,
148	.ybbp = 2,	148	.ybbp = 2,
149	.remove_padding = 0,	149	.remove_padding = false,
150	}, {	150	}, {
151	.fourcc = V4L2_PIX_FMT_NV12,	151	.fourcc = V4L2_PIX_FMT_NV12,
152	.mmal = MMAL_ENCODING_NV12,	152	.mmal = MMAL_ENCODING_NV12,
153	.depth = 12,	153	.depth = 12,
154	.mmal_component = COMP_CAMERA,	154	.mmal_component = COMP_CAMERA,
155	.ybbp = 1,	155	.ybbp = 1,
156	.remove_padding = 1,	156	.remove_padding = true,
157	}, {	157	}, {
158	.fourcc = V4L2_PIX_FMT_BGR24,	158	.fourcc = V4L2_PIX_FMT_BGR24,
159	.mmal = MMAL_ENCODING_BGR24,	159	.mmal = MMAL_ENCODING_BGR24,
160	.depth = 24,	160	.depth = 24,
161	.mmal_component = COMP_CAMERA,	161	.mmal_component = COMP_CAMERA,
162	.ybbp = 3,	162	.ybbp = 3,
163	.remove_padding = 0,	163	.remove_padding = false,
164	}, {	164	}, {
165	.fourcc = V4L2_PIX_FMT_YVU420,	165	.fourcc = V4L2_PIX_FMT_YVU420,
166	.mmal = MMAL_ENCODING_YV12,	166	.mmal = MMAL_ENCODING_YV12,
167	.depth = 12,	167	.depth = 12,
168	.mmal_component = COMP_CAMERA,	168	.mmal_component = COMP_CAMERA,
169	.ybbp = 1,	169	.ybbp = 1,
170	.remove_padding = 1,	170	.remove_padding = true,
171	}, {	171	}, {
172	.fourcc = V4L2_PIX_FMT_NV21,	172	.fourcc = V4L2_PIX_FMT_NV21,
173	.mmal = MMAL_ENCODING_NV21,	173	.mmal = MMAL_ENCODING_NV21,
174	.depth = 12,	174	.depth = 12,
175	.mmal_component = COMP_CAMERA,	175	.mmal_component = COMP_CAMERA,
176	.ybbp = 1,	176	.ybbp = 1,
177	.remove_padding = 1,	177	.remove_padding = true,
178	}, {	178	}, {
179	.fourcc = V4L2_PIX_FMT_BGR32,	179	.fourcc = V4L2_PIX_FMT_BGR32,
180	.mmal = MMAL_ENCODING_BGRA,	180	.mmal = MMAL_ENCODING_BGRA,
181	.depth = 32,	181	.depth = 32,
182	.mmal_component = COMP_CAMERA,	182	.mmal_component = COMP_CAMERA,
183	.ybbp = 4,	183	.ybbp = 4,
184	.remove_padding = 0,	184	.remove_padding = false,
185	},	185	},
186	};	186	};
187		187
@@ -1147,7 +1147,7 @@ static int mmal_setup_components(struct bcm2835_mmal_dev *dev, · 959 unmodified lines
1147	struct vchiq_mmal_port port = NULL, camera_port = NULL;	1147	struct vchiq_mmal_port port = NULL, camera_port = NULL;
1148	struct vchiq_mmal_component *encode_component = NULL;	1148	struct vchiq_mmal_component *encode_component = NULL;
1149	struct mmal_fmt *mfmt = get_format(f);	1149	struct mmal_fmt *mfmt = get_format(f);
1150	u32 remove_padding;	1150	bool remove_padding;
1151		1151
1152	if (!mfmt)	1152	if (!mfmt)
1153	return -EINVAL;	1153	return -EINVAL;

drivers/staging/vc04_services/vchiq-mmal/mmal-vchiq.c+9−9

@@ -863,9 +863,9 @@ static int port_info_get(struct vchiq_mmal_instance *instance, · 862 unmodified lines
863	goto release_msg;	863	goto release_msg;
864		864
865	if (rmsg->u.port_info_get_reply.port.is_enabled == 0)	865	if (rmsg->u.port_info_get_reply.port.is_enabled == 0)
866	port->enabled = 0;	866	port->enabled = false;
867	else	867	else
868	port->enabled = 1;	868	port->enabled = true;
869		869
870	/* copy the values out of the message */	870	/* copy the values out of the message */
871	port->handle = rmsg->u.port_info_get_reply.port_handle;	871	port->handle = rmsg->u.port_info_get_reply.port_handle;
@@ -1304,7 +1304,7 @@ static int port_disable(struct vchiq_mmal_instance *instance, · 432 unmodified lines
1304	if (!port->enabled)	1304	if (!port->enabled)
1305	return 0;	1305	return 0;
1306		1306
1307	port->enabled = 0;	1307	port->enabled = false;
1308		1308
1309	ret = port_action_port(instance, port,	1309	ret = port_action_port(instance, port,
1310	MMAL_MSG_PORT_ACTION_TYPE_DISABLE);	1310	MMAL_MSG_PORT_ACTION_TYPE_DISABLE);
@@ -1359,7 +1359,7 @@ static int port_enable(struct vchiq_mmal_instance *instance, · 48 unmodified lines
1359	if (ret)	1359	if (ret)
1360	goto done;	1360	goto done;
1361		1361
1362	port->enabled = 1;	1362	port->enabled = true;
1363		1363
1364	if (port->buffer_cb) {	1364	if (port->buffer_cb) {
1365	/* send buffer headers to videocore */	1365	/* send buffer headers to videocore */
@@ -1531,7 +1531,7 @@ int vchiq_mmal_port_connect_tunnel(struct vchiq_mmal_instance *instance, · 165 unmodified lines
1531	pr_err("failed disconnecting src port\n");	1531	pr_err("failed disconnecting src port\n");
1532	goto release_unlock;	1532	goto release_unlock;
1533	}	1533	}
1534	src->connected->enabled = 0;	1534	src->connected->enabled = false;
1535	src->connected = NULL;	1535	src->connected = NULL;
1536	}	1536	}
1537		1537
@@ -1648,7 +1648,7 @@ int vchiq_mmal_component_init(struct vchiq_mmal_instance *instance, · 110 unmodified lines
1648	for (idx = 0; idx < VCHIQ_MMAL_MAX_COMPONENTS; idx++) {	1648	for (idx = 0; idx < VCHIQ_MMAL_MAX_COMPONENTS; idx++) {
1649	if (!instance->component[idx].in_use) {	1649	if (!instance->component[idx].in_use) {
1650	component = &instance->component[idx];	1650	component = &instance->component[idx];
1651	component->in_use = 1;	1651	component->in_use = true;
1652	break;	1652	break;
1653	}	1653	}
1654	}	1654	}
@@ -1724,7 +1724,7 @@ release_component: · 69 unmodified lines
1724	destroy_component(instance, component);	1724	destroy_component(instance, component);
1725	unlock:	1725	unlock:
1726	if (component)	1726	if (component)
1727	component->in_use = 0;	1727	component->in_use = false;
1728	mutex_unlock(&instance->vchiq_mutex);	1728	mutex_unlock(&instance->vchiq_mutex);
1729		1729
1730	return ret;	1730	return ret;
@@ -1747,7 +1747,7 @@ int vchiq_mmal_component_finalise(struct vchiq_mmal_instance *instance, · 16 unmodified lines
1747		1747
1748	ret = destroy_component(instance, component);	1748	ret = destroy_component(instance, component);
1749		1749
1750	component->in_use = 0;	1750	component->in_use = false;
1751		1751
1752	mutex_unlock(&instance->vchiq_mutex);	1752	mutex_unlock(&instance->vchiq_mutex);
1753		1753
@@ -1799,7 +1799,7 @@ int vchiq_mmal_component_disable(struct vchiq_mmal_instance *instance, · 45 unmodified lines
1799		1799
1800	ret = disable_component(instance, component);	1800	ret = disable_component(instance, component);
1801	if (ret == 0)	1801	if (ret == 0)
1802	component->enabled = 0;	1802	component->enabled = false;
1803		1803
1804	mutex_unlock(&instance->vchiq_mutex);	1804	mutex_unlock(&instance->vchiq_mutex);
1805		1805

drivers/staging/vc04_services/vchiq-mmal/mmal-vchiq.h+3−3

@@ -48,7 +48,7 @@ typedef void (*vchiq_mmal_buffer_cb)( · 47 unmodified lines
48	int status, struct mmal_buffer *buffer);	48	int status, struct mmal_buffer *buffer);
49		49
50	struct vchiq_mmal_port {	50	struct vchiq_mmal_port {
51	u32 enabled:1;	51	bool enabled;
52	u32 handle;	52	u32 handle;
53	u32 type; /* port type, cached to use on port info set */	53	u32 type; /* port type, cached to use on port info set */
54	u32 index; /* port index, cached to use on port info set */	54	u32 index; /* port index, cached to use on port info set */
@@ -82,8 +82,8 @@ struct vchiq_mmal_port { · 27 unmodified lines
82	};	82	};
83		83
84	struct vchiq_mmal_component {	84	struct vchiq_mmal_component {
85	u32 in_use:1;	85	bool in_use;
86	u32 enabled:1;	86	bool enabled;
87	u32 handle; /* VideoCore handle for component */	87	u32 handle; /* VideoCore handle for component */
88	u32 inputs; /* Number of input ports */	88	u32 inputs; /* Number of input ports */
89	u32 outputs; /* Number of output ports */	89	u32 outputs; /* Number of output ports */

drivers/staging/vme_user/vme.h+0−2

@@ -27,7 +27,6 @@ enum vme_resource_type { · 26 unmodified lines
27	#define VME_A64_MAX 0x10000000000000000ULL	27	#define VME_A64_MAX 0x10000000000000000ULL
28	#define VME_CRCSR_MAX 0x1000000ULL	28	#define VME_CRCSR_MAX 0x1000000ULL
29		29
30
31	/* VME Cycle Types */	30	/* VME Cycle Types */
32	#define VME_SCT 0x1	31	#define VME_SCT 0x1
33	#define VME_BLT 0x2	32	#define VME_BLT 0x2
@@ -185,6 +184,5 @@ int vme_bus_num(struct vme_dev *); · 151 unmodified lines
185	int vme_register_driver(struct vme_driver *, unsigned int);	184	int vme_register_driver(struct vme_driver *, unsigned int);
186	void vme_unregister_driver(struct vme_driver *);	185	void vme_unregister_driver(struct vme_driver *);
187		186
188
189	#endif /* _VME_H_ */	187	#endif /* _VME_H_ */
190		188

drivers/staging/vme_user/vme_fake.c+3−6

 	return 0;
 }
 static int fake_master_get(struct vme_master_resource *image, int *enabled,
 		unsigned long long *vme_base, unsigned long long *size,
 		u32 *aspace, u32 *cycle, u32 *dwidth)
 	return retval;
 }
 static void fake_lm_check(struct fake_driver *bridge, unsigned long long addr,
 			  u32 aspace, u32 cycle)
 {
 	kfree(bridge->crcsr_kernel);
 }
 static int __init fake_init(void)
 {
 	int retval, i;
 	struct vme_lm_resource *lm;
 	/* We need a fake parent device */
-	vme_root = __root_device_register("vme", THIS_MODULE);
+	vme_root = root_device_register("vme");
+	if (IS_ERR(vme_root))
+		return PTR_ERR(vme_root);
 	/* If we want to support more than one bridge at some point, we need to
 	 * dynamically allocate this so we get one per device.
 }
 static void __exit fake_exit(void)
 {
 	struct list_head *pos = NULL;
 	root_device_unregister(vme_root);
 }
 MODULE_PARM_DESC(geoid, "Set geographical addressing");
 module_param(geoid, int, 0);

drivers/staging/vme_user/vme_tsi148.c+1−6

 static int tsi148_probe(struct pci_dev *, const struct pci_device_id *);
 static void tsi148_remove(struct pci_dev *);
 /* Module parameter */
 static bool err_chk;
 static int geoid;
 	/* Need granularity before we set the size */
 	*size = (unsigned long long)((vme_bound - *vme_base) + granularity);
 	if ((ctl & TSI148_LCSR_ITAT_2eSSTM_M) == TSI148_LCSR_ITAT_2eSSTM_160)
 		*cycle |= VME_2eSST160;
 	if ((ctl & TSI148_LCSR_ITAT_2eSSTM_M) == TSI148_LCSR_ITAT_2eSSTM_267)
 	return 0;
 }
 static int tsi148_master_get(struct vme_master_resource *image, int *enabled,
 	unsigned long long *vme_base, unsigned long long *size, u32 *aspace,
 	u32 *cycle, u32 *dwidth)
 	return retval;
 }
 static ssize_t tsi148_master_write(struct vme_master_resource *image, void *buf,
 	size_t count, loff_t offset)
 {
 	return 0;
 err_dma:
+	list_del(&entry->list);
 err_dest:
 err_source:
 err_align:
 	if ((lm_ctl & TSI148_LCSR_LMAT_AS_M) == TSI148_LCSR_LMAT_AS_A64)
 		*aspace |= VME_A64;
 	if (lm_ctl & TSI148_LCSR_LMAT_SUPR)
 		*cycle |= VME_SUPER;
 	if (lm_ctl & TSI148_LCSR_LMAT_NPRIV)
 	bridge = tsi148_bridge->driver_priv;
 	dev_dbg(&pdev->dev, "Driver is being unloaded.\n");
 	/*

drivers/staging/vme_user/vme_tsi148.h+0−7

@@ -87,7 +87,6 @@ struct tsi148_dma_entry { · 86 unmodified lines
87	* Control and Status Registers	87	* Control and Status Registers
88	*/	88	*/
89		89
90
91	/*	90	/*
92	* Command/Status Registers (CRG + $004)	91	* Command/Status Registers (CRG + $004)
93	*/	92	*/
@@ -342,7 +341,6 @@ static const int TSI148_LCSR_VIACK[8] = { 0, TSI148_LCSR_VIACK1, · 248 unmodified lines
342	#define TSI148_LCSR_IT7_ITOFL 0x3F4	341	#define TSI148_LCSR_IT7_ITOFL 0x3F4
343	#define TSI148_LCSR_IT7_ITAT 0x3F8	342	#define TSI148_LCSR_IT7_ITAT 0x3F8
344		343
345
346	#define TSI148_LCSR_IT0 0x300	344	#define TSI148_LCSR_IT0 0x300
347	#define TSI148_LCSR_IT1 0x320	345	#define TSI148_LCSR_IT1 0x320
348	#define TSI148_LCSR_IT2 0x340	346	#define TSI148_LCSR_IT2 0x340
@@ -464,7 +462,6 @@ static const int TSI148_LCSR_IT[8] = { TSI148_LCSR_IT0, TSI148_LCSR_IT1, · 115 unmodified lines
464	#define TSI148_LCSR_DMA0 0x500	462	#define TSI148_LCSR_DMA0 0x500
465	#define TSI148_LCSR_DMA1 0x580	463	#define TSI148_LCSR_DMA1 0x580
466		464
467
468	static const int TSI148_LCSR_DMA[TSI148_MAX_DMA] = { TSI148_LCSR_DMA0,	465	static const int TSI148_LCSR_DMA[TSI148_MAX_DMA] = { TSI148_LCSR_DMA0,
469	TSI148_LCSR_DMA1 };	466	TSI148_LCSR_DMA1 };
470		467
@@ -532,9 +529,6 @@ static const int TSI148_GCSR_MBOX[4] = { TSI148_GCSR_MBOX0, · 61 unmodified lines
532	#define TSI148_CSRBSR 0xFF8	529	#define TSI148_CSRBSR 0xFF8
533	#define TSI148_CBAR 0xFFC	530	#define TSI148_CBAR 0xFFC
534		531
535
536
537
538	/*	532	/*
539	* TSI148 Register Bit Definitions	533	* TSI148 Register Bit Definitions
540	*/	534	*/
@@ -828,7 +822,6 @@ static const int TSI148_GCSR_MBOX[4] = { TSI148_GCSR_MBOX0, · 287 unmodified lines
828	#define TSI148_LCSR_VEAT_AM_M (0x3F<<8) /* Address Mode Mask */	822	#define TSI148_LCSR_VEAT_AM_M (0x3F<<8) /* Address Mode Mask */
829	#define TSI148_LCSR_VEAT_XAM_M (0xFF<<0) /* Master AMode Mask */	823	#define TSI148_LCSR_VEAT_XAM_M (0xFF<<0) /* Master AMode Mask */
830		824
831
832	/*	825	/*
833	* VMEbus PCI Error Diagnostics PCI/X Attributes Register CRG + $280	826	* VMEbus PCI Error Diagnostics PCI/X Attributes Register CRG + $280
834	*/	827	*/

drivers/staging/vt6655/rxtx.c+18−18

drivers/staging/wlan-ng/TODO+16−0

@@ -0,0 +1,16 @@
	1	To-do list:
	2
	3	* Correct the coding style according to Linux guidelines; please read the document
	4	at https://www.kernel.org/doc/html/latest/process/coding-style.html.
	5	* Remove unnecessary debugging/printing macros; for those that are still needed
	6	use the proper kernel API (pr_debug(), dev_dbg(), netdev_dbg()).
	7	* Remove dead code such as unusued functions, variables, fields, etc..
	8	* Use in-kernel API and remove unnecessary wrappers where possible.
	9	* Fix bugs due to code that sleeps in atomic context.
	10	* Remove the HAL layer and migrate its functionality into the relevant parts of
	11	the driver.
	12	* Switch to use LIB80211.
	13	* Switch to use MAC80211.
	14	* Switch to use CFG80211.
	15	* Improve the error handling of various functions, particularly those that use
	16	existing kernel APIs.

drivers/staging/wlan-ng/p80211mgmt.h+0−301

@@ -217,305 +217,4 @@ · 216 unmodified lines
217	#define WLAN_SET_MGMT_CAP_INFO_PBCC(n) ((n) << 6)	217	#define WLAN_SET_MGMT_CAP_INFO_PBCC(n) ((n) << 6)
218	#define WLAN_SET_MGMT_CAP_INFO_AGILITY(n) ((n) << 7)	218	#define WLAN_SET_MGMT_CAP_INFO_AGILITY(n) ((n) << 7)
219		219
220	/-- Information Element Types --------------------/
221	/* prototype structure, all IEs start with these members */
222
223	struct wlan_ie {
224	u8 eid;
225	u8 len;
226	} __packed;
227
228	/-- Service Set Identity (SSID) -----------------/
229	struct wlan_ie_ssid {
230	u8 eid;
231	u8 len;
232	u8 ssid[1]; /* may be zero, ptrs may overlap */
233	} __packed;
234
235	/-- Supported Rates -----------------------------/
236	struct wlan_ie_supp_rates {
237	u8 eid;
238	u8 len;
239	u8 rates[1]; /* had better be at LEAST one! */
240	} __packed;
241
242	/-- FH Parameter Set ----------------------------/
243	struct wlan_ie_fh_parms {
244	u8 eid;
245	u8 len;
246	u16 dwell;
247	u8 hopset;
248	u8 hoppattern;
249	u8 hopindex;
250	} __packed;
251
252	/-- DS Parameter Set ----------------------------/
253	struct wlan_ie_ds_parms {
254	u8 eid;
255	u8 len;
256	u8 curr_ch;
257	} __packed;
258
259	/-- CF Parameter Set ----------------------------/
260
261	struct wlan_ie_cf_parms {
262	u8 eid;
263	u8 len;
264	u8 cfp_cnt;
265	u8 cfp_period;
266	u16 cfp_maxdur;
267	u16 cfp_durremaining;
268	} __packed;
269
270	/-- TIM ------------------------------------------/
271	struct wlan_ie_tim {
272	u8 eid;
273	u8 len;
274	u8 dtim_cnt;
275	u8 dtim_period;
276	u8 bitmap_ctl;
277	u8 virt_bm[1];
278	} __packed;
279
280	/-- IBSS Parameter Set ---------------------------/
281	struct wlan_ie_ibss_parms {
282	u8 eid;
283	u8 len;
284	u16 atim_win;
285	} __packed;
286
287	/-- Challenge Text ------------------------------/
288	struct wlan_ie_challenge {
289	u8 eid;
290	u8 len;
291	u8 challenge[1];
292	} __packed;
293
294	/-------------------------------------------------/
295	/* Frame Types */
296
297	/* prototype structure, all mgmt frame types will start with these members */
298	struct wlan_fr_mgmt {
299	u16 type;
300	u16 len; /* DOES NOT include CRC !!!! */
301	u8 *buf;
302	struct p80211_hdr *hdr;
303	/* used for target specific data, skb in Linux */
304	void *priv;
305	/-- fixed fields -----------/
306	/-- info elements ----------/
307	};
308
309	/-- Beacon ---------------------------------------/
310	struct wlan_fr_beacon {
311	u16 type;
312	u16 len;
313	u8 *buf;
314	struct p80211_hdr *hdr;
315	/* used for target specific data, skb in Linux */
316	void *priv;
317	/-- fixed fields -----------/
318	u64 *ts;
319	u16 *bcn_int;
320	u16 *cap_info;
321	/-- info elements ----------/
322	struct wlan_ie_ssid *ssid;
323	struct wlan_ie_supp_rates *supp_rates;
324	struct wlan_ie_fh_parms *fh_parms;
325	struct wlan_ie_ds_parms *ds_parms;
326	struct wlan_ie_cf_parms *cf_parms;
327	struct wlan_ie_ibss_parms *ibss_parms;
328	struct wlan_ie_tim *tim;
329
330	};
331
332	/-- IBSS ATIM ------------------------------------/
333	struct wlan_fr_ibssatim {
334	u16 type;
335	u16 len;
336	u8 *buf;
337	struct p80211_hdr *hdr;
338	/* used for target specific data, skb in Linux */
339	void *priv;
340
341	/-- fixed fields -----------/
342	/-- info elements ----------/
343
344	/* this frame type has a null body */
345
346	};
347
348	/-- Disassociation -------------------------------/
349	struct wlan_fr_disassoc {
350	u16 type;
351	u16 len;
352	u8 *buf;
353	struct p80211_hdr *hdr;
354	/* used for target specific data, skb in Linux */
355	void *priv;
356	/-- fixed fields -----------/
357	u16 *reason;
358
359	/-- info elements ----------/
360
361	};
362
363	/-- Association Request --------------------------/
364	struct wlan_fr_assocreq {
365	u16 type;
366	u16 len;
367	u8 *buf;
368	struct p80211_hdr *hdr;
369	/* used for target specific data, skb in Linux */
370	void *priv;
371	/-- fixed fields -----------/
372	u16 *cap_info;
373	u16 *listen_int;
374	/-- info elements ----------/
375	struct wlan_ie_ssid *ssid;
376	struct wlan_ie_supp_rates *supp_rates;
377
378	};
379
380	/-- Association Response -------------------------/
381	struct wlan_fr_assocresp {
382	u16 type;
383	u16 len;
384	u8 *buf;
385	struct p80211_hdr *hdr;
386	/* used for target specific data, skb in Linux */
387	void *priv;
388	/-- fixed fields -----------/
389	u16 *cap_info;
390	u16 *status;
391	u16 *aid;
392	/-- info elements ----------/
393	struct wlan_ie_supp_rates *supp_rates;
394
395	};
396
397	/-- Reassociation Request ------------------------/
398	struct wlan_fr_reassocreq {
399	u16 type;
400	u16 len;
401	u8 *buf;
402	struct p80211_hdr *hdr;
403	/* used for target specific data, skb in Linux */
404	void *priv;
405	/-- fixed fields -----------/
406	u16 *cap_info;
407	u16 *listen_int;
408	u8 *curr_ap;
409	/-- info elements ----------/
410	struct wlan_ie_ssid *ssid;
411	struct wlan_ie_supp_rates *supp_rates;
412
413	};
414
415	/-- Reassociation Response -----------------------/
416	struct wlan_fr_reassocresp {
417	u16 type;
418	u16 len;
419	u8 *buf;
420	struct p80211_hdr *hdr;
421	/* used for target specific data, skb in Linux */
422	void *priv;
423	/-- fixed fields -----------/
424	u16 *cap_info;
425	u16 *status;
426	u16 *aid;
427	/-- info elements ----------/
428	struct wlan_ie_supp_rates *supp_rates;
429
430	};
431
432	/-- Probe Request --------------------------------/
433	struct wlan_fr_probereq {
434	u16 type;
435	u16 len;
436	u8 *buf;
437	struct p80211_hdr *hdr;
438	/* used for target specific data, skb in Linux */
439	void *priv;
440	/-- fixed fields -----------/
441	/-- info elements ----------/
442	struct wlan_ie_ssid *ssid;
443	struct wlan_ie_supp_rates *supp_rates;
444
445	};
446
447	/-- Probe Response -------------------------------/
448	struct wlan_fr_proberesp {
449	u16 type;
450	u16 len;
451	u8 *buf;
452	struct p80211_hdr *hdr;
453	/* used for target specific data, skb in Linux */
454	void *priv;
455	/-- fixed fields -----------/
456	u64 *ts;
457	u16 *bcn_int;
458	u16 *cap_info;
459	/-- info elements ----------/
460	struct wlan_ie_ssid *ssid;
461	struct wlan_ie_supp_rates *supp_rates;
462	struct wlan_ie_fh_parms *fh_parms;
463	struct wlan_ie_ds_parms *ds_parms;
464	struct wlan_ie_cf_parms *cf_parms;
465	struct wlan_ie_ibss_parms *ibss_parms;
466	};
467
468	/-- Authentication -------------------------------/
469	struct wlan_fr_authen {
470	u16 type;
471	u16 len;
472	u8 *buf;
473	struct p80211_hdr *hdr;
474	/* used for target specific data, skb in Linux */
475	void *priv;
476	/-- fixed fields -----------/
477	u16 *auth_alg;
478	u16 *auth_seq;
479	u16 *status;
480	/-- info elements ----------/
481	struct wlan_ie_challenge *challenge;
482
483	};
484
485	/-- Deauthenication -----------------------------/
486	struct wlan_fr_deauthen {
487	u16 type;
488	u16 len;
489	u8 *buf;
490	struct p80211_hdr *hdr;
491	/* used for target specific data, skb in Linux */
492	void *priv;
493	/-- fixed fields -----------/
494	u16 *reason;
495
496	/-- info elements ----------/
497
498	};
499
500	void wlan_mgmt_encode_beacon(struct wlan_fr_beacon *f);
501	void wlan_mgmt_decode_beacon(struct wlan_fr_beacon *f);
502	void wlan_mgmt_encode_disassoc(struct wlan_fr_disassoc *f);
503	void wlan_mgmt_decode_disassoc(struct wlan_fr_disassoc *f);
504	void wlan_mgmt_encode_assocreq(struct wlan_fr_assocreq *f);
505	void wlan_mgmt_decode_assocreq(struct wlan_fr_assocreq *f);
506	void wlan_mgmt_encode_assocresp(struct wlan_fr_assocresp *f);
507	void wlan_mgmt_decode_assocresp(struct wlan_fr_assocresp *f);
508	void wlan_mgmt_encode_reassocreq(struct wlan_fr_reassocreq *f);
509	void wlan_mgmt_decode_reassocreq(struct wlan_fr_reassocreq *f);
510	void wlan_mgmt_encode_reassocresp(struct wlan_fr_reassocresp *f);
511	void wlan_mgmt_decode_reassocresp(struct wlan_fr_reassocresp *f);
512	void wlan_mgmt_encode_probereq(struct wlan_fr_probereq *f);
513	void wlan_mgmt_decode_probereq(struct wlan_fr_probereq *f);
514	void wlan_mgmt_encode_proberesp(struct wlan_fr_proberesp *f);
515	void wlan_mgmt_decode_proberesp(struct wlan_fr_proberesp *f);
516	void wlan_mgmt_encode_authen(struct wlan_fr_authen *f);
517	void wlan_mgmt_decode_authen(struct wlan_fr_authen *f);
518	void wlan_mgmt_encode_deauthen(struct wlan_fr_deauthen *f);
519	void wlan_mgmt_decode_deauthen(struct wlan_fr_deauthen *f);
520
521	#endif /* _P80211MGMT_H */	220	#endif /* _P80211MGMT_H */

drivers/staging/wlan-ng/p80211netdev.c+0−22

 		wlandev->rx.mgmt++;
 		switch (fstype) {
 		case WLAN_FSTYPE_ASSOCREQ:
-			/* printk("assocreq"); */
 			wlandev->rx.assocreq++;
 			break;
 		case WLAN_FSTYPE_ASSOCRESP:
-			/* printk("assocresp"); */
 			wlandev->rx.assocresp++;
 			break;
 		case WLAN_FSTYPE_REASSOCREQ:
-			/* printk("reassocreq"); */
 			wlandev->rx.reassocreq++;
 			break;
 		case WLAN_FSTYPE_REASSOCRESP:
-			/* printk("reassocresp"); */
 			wlandev->rx.reassocresp++;
 			break;
 		case WLAN_FSTYPE_PROBEREQ:
-			/* printk("probereq"); */
 			wlandev->rx.probereq++;
 			break;
 		case WLAN_FSTYPE_PROBERESP:
-			/* printk("proberesp"); */
 			wlandev->rx.proberesp++;
 			break;
 		case WLAN_FSTYPE_BEACON:
-			/* printk("beacon"); */
 			wlandev->rx.beacon++;
 			break;
 		case WLAN_FSTYPE_ATIM:
-			/* printk("atim"); */
 			wlandev->rx.atim++;
 			break;
 		case WLAN_FSTYPE_DISASSOC:
-			/* printk("disassoc"); */
 			wlandev->rx.disassoc++;
 			break;
 		case WLAN_FSTYPE_AUTHEN:
-			/* printk("authen"); */
 			wlandev->rx.authen++;
 			break;
 		case WLAN_FSTYPE_DEAUTHEN:
-			/* printk("deauthen"); */
 			wlandev->rx.deauthen++;
 			break;
 		default:
-			/* printk("unknown"); */
 			wlandev->rx.mgmt_unknown++;
 			break;
 		}
-		/* printk("\n"); */
 		drop = 2;
 		break;
 		wlandev->rx.ctl++;
 		switch (fstype) {
 		case WLAN_FSTYPE_PSPOLL:
-			/* printk("pspoll"); */
 			wlandev->rx.pspoll++;
 			break;
 		case WLAN_FSTYPE_RTS:
-			/* printk("rts"); */
 			wlandev->rx.rts++;
 			break;
 		case WLAN_FSTYPE_CTS:
-			/* printk("cts"); */
 			wlandev->rx.cts++;
 			break;
 		case WLAN_FSTYPE_ACK:
-			/* printk("ack"); */
 			wlandev->rx.ack++;
 			break;
 		case WLAN_FSTYPE_CFEND:
-			/* printk("cfend"); */
 			wlandev->rx.cfend++;
 			break;
 		case WLAN_FSTYPE_CFENDCFACK:
-			/* printk("cfendcfack"); */
 			wlandev->rx.cfendcfack++;
 			break;
 		default:
-			/* printk("unknown"); */
 			wlandev->rx.ctl_unknown++;
 			break;
 		}
-		/* printk("\n"); */
 		drop = 2;
 		break;
 			wlandev->rx.cfack_cfpoll++;
 			break;
 		default:
-			/* printk("unknown"); */
 			wlandev->rx.data_unknown++;
 			break;
 		}

drivers/staging/wlan-ng/p80211types.h+0−6

 	u8 data[MAXLEN_PSTR32];
 } __packed;
-/* MAC address array */
-struct p80211macarray {
-	u32 cnt;
-	u8 data[1][MAXLEN_PSTR6];
-} __packed;
 /* prototype template */
 struct p80211item {
 	u32 did;

Merge tag 'staging-6.2-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -295,19 +295,19 @@ static inline u32 wifi_mac_hash(u8 *mac) · 294 unmodified lines
295	return x;	295	return x;
296	}	296	}
297		297
298	extern u32 _rtw_init_sta_priv(struct sta_priv *pstapriv);	298	int _rtw_init_sta_priv(struct sta_priv *pstapriv);
299	extern void _rtw_free_sta_priv(struct sta_priv *pstapriv);	299	void _rtw_free_sta_priv(struct sta_priv *pstapriv);
300		300
301	#define stainfo_offset_valid(offset) (offset < NUM_STA && offset >= 0)	301	#define stainfo_offset_valid(offset) (offset < NUM_STA && offset >= 0)
302	int rtw_stainfo_offset(struct sta_priv stapriv, struct sta_info sta);	302	int rtw_stainfo_offset(struct sta_priv stapriv, struct sta_info sta);
303	struct sta_info rtw_get_stainfo_by_offset(struct sta_priv stapriv, int off);	303	struct sta_info rtw_get_stainfo_by_offset(struct sta_priv stapriv, int off);
304		304
305	extern struct sta_info rtw_alloc_stainfo(struct sta_priv stapriv, u8 *hwaddr);	305	struct sta_info rtw_alloc_stainfo(struct sta_priv stapriv, u8 *hwaddr);
306	extern u32 rtw_free_stainfo(struct adapter adapt, struct sta_info psta);	306	void rtw_free_stainfo(struct adapter adapt, struct sta_info psta);
307	extern void rtw_free_all_stainfo(struct adapter *adapt);	307	void rtw_free_all_stainfo(struct adapter *adapt);
308	extern struct sta_info rtw_get_stainfo(struct sta_priv stapriv, u8 *hwaddr);	308	struct sta_info rtw_get_stainfo(struct sta_priv stapriv, u8 *hwaddr);
309	extern u32 rtw_init_bcmc_stainfo(struct adapter *adapt);	309	u32 rtw_init_bcmc_stainfo(struct adapter *adapt);
310	extern struct sta_info rtw_get_bcmc_stainfo(struct adapter padapter);	310	struct sta_info rtw_get_bcmc_stainfo(struct adapter padapter);
311	extern u8 rtw_access_ctrl(struct adapter padapter, u8 mac_addr);	311	u8 rtw_access_ctrl(struct adapter padapter, u8 mac_addr);
312		312
313	#endif /* _STA_INFO_H_ */	313	#endif /* _STA_INFO_H_ */

@@ -18,15 +18,15 @@ · 17 unmodified lines
18	#include "drv_types.h"	18	#include "drv_types.h"
19	#include <linux/skbuff.h>	19	#include <linux/skbuff.h>
20		20
21	void _r8712_init_recv_priv(struct recv_priv *precvpriv,	21	int _r8712_init_recv_priv(struct recv_priv *precvpriv,
22	struct _adapter *padapter);	22	struct _adapter *padapter);
23	void _r8712_free_recv_priv(struct recv_priv *precvpriv);	23	void _r8712_free_recv_priv(struct recv_priv *precvpriv);
24	void r8712_recv_entry(union recv_frame *precv_frame);	24	void r8712_recv_entry(union recv_frame *precv_frame);
25	void r8712_recv_indicatepkt(struct _adapter *adapter,	25	void r8712_recv_indicatepkt(struct _adapter *adapter,
26	union recv_frame *precv_frame);	26	union recv_frame *precv_frame);
27	void r8712_handle_tkip_mic_err(struct _adapter *padapter, u8 bgroup);	27	void r8712_handle_tkip_mic_err(struct _adapter *padapter, u8 bgroup);
28	void r8712_init_recv_priv(struct recv_priv *precvpriv,	28	int r8712_init_recv_priv(struct recv_priv *precvpriv,
29	struct _adapter *padapter);	29	struct _adapter *padapter);
30	void r8712_free_recv_priv(struct recv_priv *precvpriv);	30	void r8712_free_recv_priv(struct recv_priv *precvpriv);
31	void r8712_os_recv_resource_alloc(struct _adapter *padapter,	31	void r8712_os_recv_resource_alloc(struct _adapter *padapter,
32	union recv_frame *precvframe);	32	union recv_frame *precvframe);

@@ -54,17 +54,17 @@ · 53 unmodified lines
54	*/	54	*/
55	#define CRITICAL_PACKET_LEN 256	55	#define CRITICAL_PACKET_LEN 256
56		56
57	static const unsigned short wTimeStampOff[2][MAX_RATE] = {	57	static const unsigned short time_stamp_off[2][MAX_RATE] = {
58	{384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, /* Long Preamble */	58	{384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, /* Long Preamble */
59	{384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, /* Short Preamble */	59	{384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, /* Short Preamble */
60	};	60	};
61		61
62	static const unsigned short wFB_Opt0[2][5] = {	62	static const unsigned short fb_opt0[2][5] = {
63	{RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, /* fallback_rate0 */	63	{RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, /* fallback_rate0 */
64	{RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, /* fallback_rate1 */	64	{RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, /* fallback_rate1 */
65	};	65	};
66		66
67	static const unsigned short wFB_Opt1[2][5] = {	67	static const unsigned short fb_opt1[2][5] = {
68	{RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, /* fallback_rate0 */	68	{RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, /* fallback_rate0 */
69	{RATE_6M, RATE_6M, RATE_12M, RATE_12M, RATE_18M}, /* fallback_rate1 */	69	{RATE_6M, RATE_6M, RATE_12M, RATE_12M, RATE_18M}, /* fallback_rate1 */
70	};	70	};
@@ -142,7 +142,7 @@ s_uFillDataHead( · 71 unmodified lines
142		142
143	static __le16 vnt_time_stamp_off(struct vnt_private *priv, u16 rate)	143	static __le16 vnt_time_stamp_off(struct vnt_private *priv, u16 rate)
144	{	144	{
145	return cpu_to_le16(wTimeStampOff[priv->preamble_type % 2]	145	return cpu_to_le16(time_stamp_off[priv->preamble_type % 2]
146	[rate % MAX_RATE]);	146	[rate % MAX_RATE]);
147	}	147	}
148		148
@@ -310,9 +310,9 @@ s_uGetDataDuration( · 161 unmodified lines
310	wRate -= RATE_18M;	310	wRate -= RATE_18M;
311		311
312	if (byFBOption == AUTO_FB_0)	312	if (byFBOption == AUTO_FB_0)
313	wRate = wFB_Opt0[FB_RATE0][wRate];	313	wRate = fb_opt0[FB_RATE0][wRate];
314	else	314	else
315	wRate = wFB_Opt1[FB_RATE0][wRate];	315	wRate = fb_opt1[FB_RATE0][wRate];
316		316
317	uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType,	317	uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType,
318	len, wRate, bNeedAck);	318	len, wRate, bNeedAck);
@@ -365,52 +365,52 @@ s_uGetRTSCTSDuration( · 46 unmodified lines
365	case RTSDUR_BA_F0: /* RTSDuration_ba_f0 */	365	case RTSDUR_BA_F0: /* RTSDuration_ba_f0 */
366	uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopCCKBasicRate);	366	uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopCCKBasicRate);
367	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	367	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
368	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate - RATE_18M], bNeedAck);	368	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE0][wRate - RATE_18M], bNeedAck);
369	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	369	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
370	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate - RATE_18M], bNeedAck);	370	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE0][wRate - RATE_18M], bNeedAck);
371		371
372	break;	372	break;
373		373
374	case RTSDUR_AA_F0: /* RTSDuration_aa_f0 */	374	case RTSDUR_AA_F0: /* RTSDuration_aa_f0 */
375	uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopOFDMBasicRate);	375	uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopOFDMBasicRate);
376	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	376	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
377	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate - RATE_18M], bNeedAck);	377	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE0][wRate - RATE_18M], bNeedAck);
378	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	378	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
379	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate - RATE_18M], bNeedAck);	379	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE0][wRate - RATE_18M], bNeedAck);
380		380
381	break;	381	break;
382		382
383	case RTSDUR_BA_F1: /* RTSDuration_ba_f1 */	383	case RTSDUR_BA_F1: /* RTSDuration_ba_f1 */
384	uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopCCKBasicRate);	384	uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopCCKBasicRate);
385	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	385	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
386	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate - RATE_18M], bNeedAck);	386	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE1][wRate - RATE_18M], bNeedAck);
387	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	387	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
388	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate - RATE_18M], bNeedAck);	388	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE1][wRate - RATE_18M], bNeedAck);
389		389
390	break;	390	break;
391		391
392	case RTSDUR_AA_F1: /* RTSDuration_aa_f1 */	392	case RTSDUR_AA_F1: /* RTSDuration_aa_f1 */
393	uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopOFDMBasicRate);	393	uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopOFDMBasicRate);
394	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	394	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
395	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate - RATE_18M], bNeedAck);	395	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE1][wRate - RATE_18M], bNeedAck);
396	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	396	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
397	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate - RATE_18M], bNeedAck);	397	uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE1][wRate - RATE_18M], bNeedAck);
398		398
399	break;	399	break;
400		400
401	case CTSDUR_BA_F0: /* CTSDuration_ba_f0 */	401	case CTSDUR_BA_F0: /* CTSDuration_ba_f0 */
402	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	402	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
403	uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate - RATE_18M], bNeedAck);	403	uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE0][wRate - RATE_18M], bNeedAck);
404	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	404	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
405	uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate - RATE_18M], bNeedAck);	405	uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE0][wRate - RATE_18M], bNeedAck);
406		406
407	break;	407	break;
408		408
409	case CTSDUR_BA_F1: /* CTSDuration_ba_f1 */	409	case CTSDUR_BA_F1: /* CTSDuration_ba_f1 */
410	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	410	if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
411	uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate - RATE_18M], bNeedAck);	411	uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE1][wRate - RATE_18M], bNeedAck);
412	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))	412	else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
413	uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate - RATE_18M], bNeedAck);	413	uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE1][wRate - RATE_18M], bNeedAck);
414		414
415	break;	415	break;
416		416