[PATCH] Decouple networking from firmware download

Move all firmware related data from struct at76_priv to struct fwentry.
Move struct fwentry to the header file.  Share the firmware data between
devices.

Never load firmware version or anything else into firmwares[], as one
broken device can mess it for others.  Use temporary structures instead.

Change at76_load_internal_fw() and at76_load_external_fw() not to
require struct at76_priv, which is allocated as part of the network
device.  at76_disconnect() should check if priv is allocated.

Don't use priv->istate to track the firmware loading, as it's done in a
predictable consecutive manner now.  No state machine is needed at this
point.  There should be no priv at all before the firmware is loaded.
Until the device is fully initialized, priv->istate should be INIT.

Don't use mutexes during firmware download for the same reason.  In
fact, they were used incorrectly since priv is not the same during
internal and external firmware download.

Parse firmware immediately after loading in a new function
at76_load_firmware() replacing at76_parse_fw() and parts of
at76_probe().

Don't access udev before usb_get_dev() is called and be careful to call
usb_put_dev() for all errors.

Improve error handling and diagnostics in the affected code.

Signed-off-by: Pavel Roskin <proski@gnu.org>

2 files changed, 182 insertions, 186 deletions

diff --git a/at76_usb.c b/at76_usb.c
index 1c23efc..ddd890b 100644
--- a/at76_usb.c
+++ b/at76_usb.c
@@ -46,11 +46,7 @@
 
 static int at76_debug = DBG_DEFAULTS;
 
-/* Firmware names */
-static struct fwentry {
-	const char *const fwname;
-	const struct firmware *fw;
-} firmwares[] = {
+static struct fwentry firmwares[] = {
 	[0]			      = { "" },
 	[BOARDTYPE_503_INTERSIL_3861] = { "atmel_at76c503-i3861.bin" },
 	[BOARDTYPE_503_INTERSIL_3863] = { "atmel_at76c503-i3863.bin" },
@@ -656,7 +652,7 @@ static int at76_get_hw_config(struct at76_priv *priv)
 	if (!hwcfg)
 		return -ENOMEM;
 
-	switch (priv->board_type) {
+	switch (priv->fwe->board_type) {
 
 	case BOARDTYPE_503_INTERSIL_3861:
 	case BOARDTYPE_503_INTERSIL_3863:
@@ -688,7 +684,7 @@ static int at76_get_hw_config(struct at76_priv *priv)
 
 	default:
 		err("Bad board type set (%d).  Unable to get hardware config.",
-		    priv->board_type);
+		    priv->fwe->board_type);
 		ret = -EINVAL;
 	}
 
@@ -2920,8 +2916,8 @@ static int at76_iw_handler_get_scan(struct net_device *netdev,
 		iwe->u.qual.level = (curr_bss->rssi * 100 / 42);
 		if (iwe->u.qual.level > 100)
 			iwe->u.qual.level = 100;
-		if ((priv->board_type == BOARDTYPE_503_INTERSIL_3861) ||
-		    (priv->board_type == BOARDTYPE_503_INTERSIL_3863)) {
+		if ((priv->fwe->board_type == BOARDTYPE_503_INTERSIL_3861) ||
+		    (priv->fwe->board_type == BOARDTYPE_503_INTERSIL_3863)) {
 			iwe->u.qual.qual = curr_bss->link_qual;
 		} else {
 			iwe->u.qual.qual = 0;
@@ -4018,8 +4014,8 @@ static void at76_ethtool_get_drvinfo(struct net_device *netdev,
 
 	snprintf(info->fw_version, sizeof(info->fw_version) - 1,
 		 "%d.%d.%d-%d",
-		 priv->fw_version.major, priv->fw_version.minor,
-		 priv->fw_version.patch, priv->fw_version.build);
+		 priv->fwe->fw_version.major, priv->fwe->fw_version.minor,
+		 priv->fwe->fw_version.patch, priv->fwe->fw_version.build);
 }
 
 
@@ -4047,6 +4043,7 @@ static int at76_init_new_device(struct at76_priv *priv)
 {
 	struct net_device *netdev = priv->netdev;
 	int ret;
+	struct mib_fw_version req_fw_version;
 
 	/* set up the endpoint information */
 	/* check out the endpoints */
@@ -4060,28 +4057,33 @@ static int at76_init_new_device(struct at76_priv *priv)
 		goto error;
 
 	/* get firmware version */
-	ret = at76_get_mib(priv->udev, MIB_FW_VERSION, &priv->fw_version,
-			   sizeof(priv->fw_version));
-	if ((ret < 0) || ((priv->fw_version.major == 0) &&
-			  (priv->fw_version.minor == 0) &&
-			  (priv->fw_version.patch == 0) &&
-			  (priv->fw_version.build == 0))) {
-		err("getting firmware failed with %d, or version is 0", ret);
+	ret = at76_get_mib(priv->udev, MIB_FW_VERSION, &req_fw_version,
+			   sizeof(req_fw_version));
+	if (ret < 0) {
+		err("error %d getting firmware version", ret);
+		ret = -ENODEV;
+		goto error;
+	}
+
+	if ((req_fw_version.major == 0) &&
+	    (req_fw_version.minor == 0) &&
+	    (req_fw_version.patch == 0) &&
+	    (req_fw_version.build == 0)) {
+		err("firmware version consists of all zeroes");
 		err("this probably means that the ext. fw was not loaded correctly");
-		if(ret >= 0)
-			ret = -ENODEV;
+		ret = -ENODEV;
 		goto error;
 	}
 
 	/* fw 0.84 doesn't send FCS with rx data */
-	if (priv->fw_version.major == 0 && priv->fw_version.minor <= 84)
+	if (req_fw_version.major == 0 && req_fw_version.minor <= 84)
 		priv->rx_data_fcs_len = 0;
 	else
 		priv->rx_data_fcs_len = 4;
 
 	info("firmware version %d.%d.%d #%d (fcs_len %d)",
-	     priv->fw_version.major, priv->fw_version.minor,
-	     priv->fw_version.patch, priv->fw_version.build,
+	     req_fw_version.major, req_fw_version.minor,
+	     req_fw_version.patch, req_fw_version.build,
 	     priv->rx_data_fcs_len);
 
 	/* MAC address */
@@ -4149,58 +4151,44 @@ static int at76_init_new_device(struct at76_priv *priv)
 
 
 /* Download external firmware */
-static int at76_load_external_fw(struct at76_priv *priv)
+static int at76_load_external_fw(struct usb_device *udev, struct fwentry *fwe)
 {
 	int ret;
 	int op_mode;
 
-	mutex_lock(&priv->mtx);
-
-	op_mode = at76_get_op_mode(priv->udev);
+	op_mode = at76_get_op_mode(udev);
 	at76_dbg(DBG_DEVSTART, "opmode %d", op_mode);
 
 	if (op_mode != OPMODE_NORMAL_NIC_WITHOUT_FLASH) {
 		err("unexpected opmode %d", op_mode);
-		ret = -EINVAL;
-		goto end_external_fw;
+		return -EINVAL;
 	}
 
-	if (priv->extfw && priv->extfw_size) {
-		ret = at76_download_external_fw(priv->udev, priv->extfw,
-						priv->extfw_size);
-		if (ret < 0) {
-			err("Downloading external firmware failed: %d", ret);
-			goto end_external_fw;
-		}
-		if (priv->board_type == BOARDTYPE_505A_RFMD_2958) {
-			info("200 ms delay for board type 7");
-			/* can we do this with priv->mtx down? */
-			schedule_timeout_interruptible(HZ / 5 + 1);
-		}
-	}
-	priv->istate = INIT;
-	mutex_unlock(&priv->mtx);
-	if ((ret = at76_init_new_device(priv)) < 0)
+	if (!fwe->extfw || !fwe->extfw_size)
+		return -ENOENT;
+
+	ret = at76_download_external_fw(udev, fwe->extfw, fwe->extfw_size);
+	if (ret < 0) {
 		err("Downloading external firmware failed: %d", ret);
-	return ret;
+		return ret;
+	}
 
-      end_external_fw:
-	mutex_unlock(&priv->mtx);
-	return ret;
+	if (fwe->board_type == BOARDTYPE_505A_RFMD_2958) {
+		info("200 ms delay for board type 7");
+		schedule_timeout_interruptible(HZ / 5 + 1);
+	}
+	return 0;
 }
 
 
 /* Download internal firmware */
-static int at76_load_internal_fw(struct at76_priv *priv)
+static int at76_load_internal_fw(struct usb_device *udev, struct fwentry *fwe)
 {
 	int ret;
+	int need_remap = (fwe->board_type != BOARDTYPE_505A_RFMD_2958);
 
-	mutex_lock(&priv->mtx);
-
-	ret = at76_usbdfu_download(priv->udev, priv->intfw,
-				   priv->intfw_size,
-				   priv->board_type ==
-				   BOARDTYPE_505A_RFMD_2958 ? 2000 : 0);
+	ret = at76_usbdfu_download(udev, fwe->intfw, fwe->intfw_size,
+				   need_remap ? 0 : 2000);
 
 	if (ret < 0) {
 		err("downloading internal fw failed with %d", ret);
@@ -4210,20 +4198,17 @@ static int at76_load_internal_fw(struct at76_priv *priv)
 	at76_dbg(DBG_DEVSTART, "sending REMAP");
 
 	/* no REMAP for 505A (see SF driver) */
-	if (priv->board_type != BOARDTYPE_505A_RFMD_2958)
-		if ((ret = at76_remap(priv->udev)) < 0) {
+	if (need_remap)
+		if ((ret = at76_remap(udev)) < 0) {
 			err("sending REMAP failed with %d", ret);
 			goto end_internal_fw;
 		}
 
 	at76_dbg(DBG_DEVSTART, "sleeping for 2 seconds");
-	priv->istate = EXTFW_DOWNLOAD;
 	schedule_timeout_interruptible(2 * HZ + 1);
-	usb_reset_device(priv->udev);
-	priv->istate = WAIT_FOR_DISCONNECT;
+	usb_reset_device(udev);
 
       end_internal_fw:
-	mutex_unlock(&priv->mtx);
 	return ret;
 }
 
@@ -5299,8 +5284,8 @@ static void at76_calc_level(struct at76_priv *priv, struct at76_rx_buffer *buf,
 static void at76_calc_qual(struct at76_priv *priv, struct at76_rx_buffer *buf,
 			   struct iw_quality* qual)
 {
-	if ((priv->board_type == BOARDTYPE_503_INTERSIL_3861) ||
-	    (priv->board_type == BOARDTYPE_503_INTERSIL_3863)) {
+	if ((priv->fwe->board_type == BOARDTYPE_503_INTERSIL_3861) ||
+	    (priv->fwe->board_type == BOARDTYPE_503_INTERSIL_3863)) {
 		qual->qual = buf->link_quality;
 	} else {
 		unsigned long msec;
@@ -5992,8 +5977,7 @@ static void at76_rx_tasklet(unsigned long param)
 }
 
 
-static struct at76_priv *at76_alloc_new_device(struct usb_device *udev,
-					       int board_type)
+static struct at76_priv *at76_alloc_new_device(struct usb_device *udev)
 {
 	struct net_device *netdev;
 	struct at76_priv *priv = NULL;
@@ -6036,7 +6020,7 @@ static struct at76_priv *at76_alloc_new_device(struct usb_device *udev,
 
 	spin_lock_init(&priv->mgmt_spinlock);
 	priv->next_mgmt_bulk = NULL;
-	priv->istate = INTFW_DOWNLOAD;
+	priv->istate = INIT;
 
 	/* initialize empty BSS list */
 	priv->curr_bss = priv->new_bss = NULL;
@@ -6056,8 +6040,6 @@ static struct at76_priv *at76_alloc_new_device(struct usb_device *udev,
 	priv->rx_tasklet.func = at76_rx_tasklet;
 	priv->rx_tasklet.data = (unsigned long)priv;
 
-	priv->board_type = board_type;
-
 	priv->pm_mode = AT76_PM_OFF;
 	priv->pm_period = 0;
 
@@ -6065,45 +6047,66 @@ static struct at76_priv *at76_alloc_new_device(struct usb_device *udev,
 }
 
 
-/* Parse the firmware image */
-static int at76_parse_fw(struct at76_priv *priv, u8 *fw_data, int fw_size,
-			 int board_type)
+/* Load firmware into kernel memory and parse it */
+static struct fwentry *at76_load_firmware(struct usb_device *udev,
+					  int board_type)
 {
+	int ret;
 	char *str;
-	struct at76_fw_header *fw = (struct at76_fw_header *)fw_data;
+	struct at76_fw_header *fwh;
+	struct fwentry *fwe = &firmwares[board_type];
 
-	if (fw_size <= sizeof(*fw)) {
-		err("firmware is too short (0x%x)", fw_size);
-		return -EFAULT;
+	if (fwe->loaded) {
+		at76_dbg(DBG_FW, "re-using previously loaded fw");
+		return fwe;
+	}
+
+	at76_dbg(DBG_FW, "downloading firmware %s", fwe->fwname);
+	ret = request_firmware(&fwe->fw, fwe->fwname, &udev->dev);
+	if (ret < 0) {
+		err("firmware %s not found.", fwe->fwname);
+		err("You may need to download the firmware from "
+		    "https://developer.berlios.de/projects/at76c503a/");
+		return NULL;
+	}
+
+	at76_dbg(DBG_FW, "got it.");
+	fwh = (struct at76_fw_header *)(fwe->fw->data);
+
+	if (fwe->fw->size <= sizeof(*fwh)) {
+		err("firmware is too short (0x%zx)", fwe->fw->size);
+		return NULL;
 	}
 
 	/* CRC currently not checked */
-	priv->board_type = le32_to_cpu(fw->board_type);
-	priv->fw_version.major = fw->major;
-	priv->fw_version.minor = fw->minor;
-	priv->fw_version.patch = fw->patch;
-	priv->fw_version.build = fw->build;
-	str = (char *)fw_data + le32_to_cpu(fw->str_offset);
-	priv->intfw = (u8 *)fw + le32_to_cpu(fw->int_fw_offset);
-	priv->intfw_size = le32_to_cpu(fw->int_fw_len);
-	priv->extfw = (u8 *)fw + le32_to_cpu(fw->ext_fw_offset);
-	priv->extfw_size = le32_to_cpu(fw->ext_fw_len);
+	fwe->board_type = le32_to_cpu(fwh->board_type);
+	if (fwe->board_type != board_type) {
+		err("board type mismatch, requested %u, got %u", board_type,
+		    fwe->board_type);
+		return NULL;
+	}
+
+	fwe->fw_version.major = fwh->major;
+	fwe->fw_version.minor = fwh->minor;
+	fwe->fw_version.patch = fwh->patch;
+	fwe->fw_version.build = fwh->build;
+
+	str = (char *)fwh + le32_to_cpu(fwh->str_offset);
+	fwe->intfw = (u8 *)fwh + le32_to_cpu(fwh->int_fw_offset);
+	fwe->intfw_size = le32_to_cpu(fwh->int_fw_len);
+	fwe->extfw = (u8 *)fwh + le32_to_cpu(fwh->ext_fw_offset);
+	fwe->extfw_size = le32_to_cpu(fwh->ext_fw_len);
+
+	fwe->loaded = 1;
 
 	at76_dbg(DBG_DEVSTART, "firmware board %u version %u.%u.%u#%u "
-		 "(int %x:%tx, ext %x:%tx)", priv->board_type,
-		 priv->fw_version.major, priv->fw_version.minor,
-		 priv->fw_version.patch, priv->fw_version.build,
-		 priv->intfw_size, priv->intfw - fw_data,
-		 priv->extfw_size, priv->extfw - fw_data);
+		 "(int %x:%x, ext %x:%x)", board_type,
+		 fwh->major, fwh->minor, fwh->patch, fwh->build,
+		 le32_to_cpu(fwh->int_fw_offset), le32_to_cpu(fwh->int_fw_len),
+		 le32_to_cpu(fwh->ext_fw_offset), le32_to_cpu(fwh->ext_fw_len));
 	at76_dbg(DBG_DEVSTART, "firmware id %s", str);
 
-	if (priv->board_type != board_type) {
-		err("inconsistent board types %u != %u", board_type,
-		    priv->board_type);
-		return -EINVAL;
-	}
-
-	return 0;
+	return fwe;
 }
 
 
@@ -6112,38 +6115,23 @@ static int at76_probe(struct usb_interface *interface,
 {
 	int ret;
 	struct at76_priv *priv;
-	int board_type = (int)id->driver_info;
-	const char *const fw_name = firmwares[board_type].fwname;
-	const struct firmware *fw = firmwares[board_type].fw;
-	struct usb_device *udev = interface_to_usbdev(interface);
+	struct fwentry *fwe;
+	struct usb_device *udev;
 	int op_mode;
+	int need_ext_fw = 0;
+	struct mib_fw_version req_fw_version;
 
-	if (fw == NULL) {
-		at76_dbg(DBG_FW, "downloading firmware %s", fw_name);
-		ret = request_firmware(&fw, fw_name, &udev->dev);
-		if (ret == 0) {
-			at76_dbg(DBG_FW, "got it.");
-		} else {
-			err("firmware %s not found.", fw_name);
-			err("You may need to download the firmware from "
-			    "https://developer.berlios.de/projects/at76c503a/");
-			return ret;
-		}
-	} else
-		at76_dbg(DBG_FW, "re-using previously loaded fw");
-
-	usb_get_dev(udev);
+	udev = usb_get_dev(interface_to_usbdev(interface));
 
-	if ((priv = at76_alloc_new_device(udev, board_type)) == NULL) {
-		ret = -ENOMEM;
-		goto error_alloc;
+	/* Load firmware into kernel memory */
+	fwe = at76_load_firmware(udev, (int)id->driver_info);
+	if (!fwe) {
+		ret = -ENOENT;
+		goto error;
 	}
 
 	op_mode = at76_get_op_mode(udev);
 
-	usb_set_intfdata(interface, priv);
-	priv->interface = interface;
-
 	at76_dbg(DBG_DEVSTART, "opmode %d", op_mode);
 
 	/* we get OPMODE_NONE with 2.4.23, SMC2662W-AR ???
@@ -6152,73 +6140,72 @@ static int at76_probe(struct usb_interface *interface,
 	if (op_mode == OPMODE_HW_CONFIG_MODE) {
 		err("cannot handle a device in HW_CONFIG_MODE (opmode %d)",
 		    op_mode);
-		ret = -ENODEV;
+		ret = -EBUSY;
 		goto error;
 	}
 
-	/* parse the firmware */
-	ret = at76_parse_fw(priv, fw->data, fw->size, board_type);
-	if (ret)
-		goto error;
-
 	if (op_mode != OPMODE_NORMAL_NIC_WITH_FLASH
 	    && op_mode != OPMODE_NORMAL_NIC_WITHOUT_FLASH) {
 		/* download internal firmware part */
 		at76_dbg(DBG_DEVSTART, "downloading internal firmware");
-		priv->istate = INTFW_DOWNLOAD;
-		ret = at76_load_internal_fw(priv);
-		if (ret)
+		ret = at76_load_internal_fw(udev, fwe);
+		if (ret < 0) {
+			err("error %d downloading internal firmware", ret);
 			goto error;
-	} else {
-		/* Internal firmware already inside the device.  Get firmware
-		 * version to test if external firmware is loaded.
-		 * This works only for newer firmware, e.g. the Intersil 0.90.x
-		 * says "control timeout on ep0in" and subsequent
-		 * at76_get_op_mode() fail too :-( */
-		int force_fw_dwl = 0;
-
-		/* if version >= 0.100.x.y or device with built-in flash we can
-		 * query the device for the fw version */
-		if ((priv->fw_version.major > 0 || priv->fw_version.minor >= 100)
-		    || (op_mode == OPMODE_NORMAL_NIC_WITH_FLASH)) {
-			ret = at76_get_mib(udev, MIB_FW_VERSION,
-					   &priv->fw_version,
-					   sizeof(priv->fw_version));
-		} else {
-			/* force fw download only if the device has no flash inside */
-			force_fw_dwl = 1;
 		}
+		usb_put_dev(udev);
+		return ret;
+	}
 
-		if ((force_fw_dwl) || (ret < 0)
-		    || ((priv->fw_version.major == 0)
-			&& (priv->fw_version.minor == 0)
-			&& (priv->fw_version.patch == 0)
-			&& (priv->fw_version.build == 0))) {
-			if (force_fw_dwl)
-				at76_dbg(DBG_DEVSTART,
-					 "forced download of external firmware part");
-			else
-				at76_dbg(DBG_DEVSTART,
-					 "cannot get firmware (ret %d) or all zeros "
-					 "- download external firmware", ret);
-
-			priv->istate = EXTFW_DOWNLOAD;
-			ret = at76_load_external_fw(priv);
-			if (ret)
-				goto error;
-		} else {
-			priv->istate = INIT;
-			if ((ret = at76_init_new_device(priv)) < 0)
-				goto error;
-		}
+	/* Internal firmware already inside the device.  Get firmware
+	 * version to test if external firmware is loaded.
+	 * This works only for newer firmware, e.g. the Intersil 0.90.x
+	 * says "control timeout on ep0in" and subsequent
+	 * at76_get_op_mode() fail too :-( */
+
+	/* if version >= 0.100.x.y or device with built-in flash we can
+	 * query the device for the fw version */
+	if ((fwe->fw_version.major > 0 || fwe->fw_version.minor >= 100)
+	    || (op_mode == OPMODE_NORMAL_NIC_WITH_FLASH)) {
+		ret = at76_get_mib(udev, MIB_FW_VERSION,
+				   &req_fw_version,
+				   sizeof(req_fw_version));
+		if ((ret < 0)
+		    || ((req_fw_version.major == 0)
+			&& (req_fw_version.minor == 0)
+			&& (req_fw_version.patch == 0)
+			&& (req_fw_version.build == 0)))
+		need_ext_fw = 1;
+	} else {
+		/* No way to check firmware version, reload to be sure */
+		need_ext_fw = 1;
 	}
-	return 0;
 
-      error:
-	at76_delete_device(priv);
+	if (need_ext_fw) {
+		at76_dbg(DBG_DEVSTART, "downloading external firmware");
+
+		ret = at76_load_external_fw(udev, fwe);
+		if (ret)
+			goto error;
+	}
+
+	priv = at76_alloc_new_device(udev);
+	if (!priv) {
+		ret = -ENOMEM;
+		goto error;
+	}
+
+	usb_set_intfdata(interface, priv);
+	priv->interface = interface;
+	priv->fwe = fwe;
+
+	ret = at76_init_new_device(priv);
+	if (ret < 0)
+		at76_delete_device(priv);
+
 	return ret;
 
-      error_alloc:
+      error:
 	usb_put_dev(udev);
 	return ret;
 }
@@ -6231,6 +6218,10 @@ static void at76_disconnect(struct usb_interface *interface)
 	priv = usb_get_intfdata(interface);
 	usb_set_intfdata(interface, NULL);
 
+	/* Disconnect after loading internal firmware */
+	if (!priv)
+		return;
+
 	info("%s disconnecting", priv->netdev->name);
 	at76_delete_device(priv);
 	info(DRIVER_NAME " disconnected");
diff --git a/at76_usb.h b/at76_usb.h
index 6169866..de5f035 100644
--- a/at76_usb.h
+++ b/at76_usb.h
@@ -388,9 +388,6 @@ enum infra_state {
 	JOINING,
 	CONNECTED,
 	STARTIBSS,
-	INTFW_DOWNLOAD,
-	EXTFW_DOWNLOAD,
-	WAIT_FOR_DISCONNECT,
 	MONITORING,
 };
 
@@ -447,6 +444,20 @@ struct rx_data_buf {
 /* how often do we try to submit a rx urb until giving up */
 #define NR_SUBMIT_RX_TRIES 8
 
+/* Data for one loaded firmware file */
+struct fwentry {
+	const char *const fwname;
+	const struct firmware *fw;
+	int extfw_size;
+	int intfw_size;
+	/* these point into a buffer managed by the firmware dl functions, no need to dealloc */
+	u8 *extfw;		/* points to external firmware part, extfw_size bytes long */
+	u8 *intfw;		/* points to internal firmware part, intfw_size bytes long */
+	u32 board_type;		/* BOARDTYPE_* in at76_usb_ids.h */
+	struct mib_fw_version fw_version;
+	int loaded;		/* Loaded and parsed successfully */
+};
+
 struct at76_priv {
 	struct usb_device *udev;	/* USB device pointer */
 	struct net_device *netdev;	/* net device pointer */
@@ -547,7 +558,6 @@ struct at76_priv {
 	int retries;		/* counts backwards while re-trying to send auth/assoc_req's */
 	u8 pm_mode;		/* power management mode: AT76_PM_{OFF, ON, SMART} */
 	u32 pm_period;		/* power manag. period in us */
-	u32 board_type;		/* BOARDTYPE_* in at76_usb_ids.h */
 
 	struct reg_domain const *domain;	/* the description of the regulatory domain */
 	int international_roaming;
@@ -564,7 +574,6 @@ struct at76_priv {
 	u8 regulatory_domain;
 
 	struct at76_card_config card_config;
-	struct mib_fw_version fw_version;
 
 	int rx_data_fcs_len;	/* length of the trailing FCS 
 				   (0 for fw <= 0.84.x, 4 otherwise) */
@@ -572,11 +581,7 @@ struct at76_priv {
 	/* store rx fragments until complete */
 	struct rx_data_buf rx_data[NR_RX_DATA_BUF];
 
-	int extfw_size;
-	int intfw_size;
-	/* these point into a buffer managed by the firmware dl functions, no need to dealloc */
-	u8 *extfw;		/* points to external firmware part, extfw_size bytes long */
-	u8 *intfw;		/* points to internal firmware part, intfw_size bytes long */
+	struct fwentry *fwe;
 	unsigned int device_unplugged:1;
 	unsigned int netdev_registered:1;
 	char obuf[2 * 256 + 1];	/* global debug output buffer to reduce stack usage */