ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
 }
 
-static int ath9k_hif_usb_download_fw(struct hif_device_usb *hif_dev)
+static int ath9k_hif_usb_download_fw(struct hif_device_usb *hif_dev,
+                                    u32 drv_info)
 {
        int transfer, err;
        const void *data = hif_dev->firmware->data;
        }
        kfree(buf);
 
-       switch (hif_dev->device_id) {
-       case 0x7010:
-       case 0x7015:
-       case 0x9018:
-       case 0xA704:
-       case 0x1200:
+       if (drv_info & AR7010_DEVICE)
                firm_offset = AR7010_FIRMWARE_TEXT;
-               break;
-       default:
+       else
                firm_offset = AR9271_FIRMWARE_TEXT;
-               break;
-       }
 
        /*
         * Issue FW download complete command to firmware.
        return 0;
 }
 
-static int ath9k_hif_usb_dev_init(struct hif_device_usb *hif_dev)
+static int ath9k_hif_usb_dev_init(struct hif_device_usb *hif_dev, u32 drv_info)
 {
        int ret, idx;
        struct usb_host_interface *alt = &hif_dev->interface->altsetting[0];
        }
 
        /* Download firmware */
-       ret = ath9k_hif_usb_download_fw(hif_dev);
+       ret = ath9k_hif_usb_download_fw(hif_dev, drv_info);
        if (ret) {
                dev_err(&hif_dev->udev->dev,
                        "ath9k_htc: Firmware - %s download failed\n",
 
        /* Find out which firmware to load */
 
-       switch(hif_dev->device_id) {
-       case 0x7010:
-       case 0x7015:
-       case 0x9018:
-       case 0xA704:
-       case 0x1200:
+       if (id->driver_info & AR7010_DEVICE)
                if (le16_to_cpu(udev->descriptor.bcdDevice) == 0x0202)
                        hif_dev->fw_name = FIRMWARE_AR7010_1_1;
                else
                        hif_dev->fw_name = FIRMWARE_AR7010;
-               break;
-       default:
+       else
                hif_dev->fw_name = FIRMWARE_AR9271;
-               break;
-       }
 
-       ret = ath9k_hif_usb_dev_init(hif_dev);
+       ret = ath9k_hif_usb_dev_init(hif_dev, id->driver_info);
        if (ret) {
                ret = -EINVAL;
                goto err_hif_init_usb;
 
        ret = ath9k_htc_hw_init(hif_dev->htc_handle,
                                &hif_dev->udev->dev, hif_dev->device_id,
-                               hif_dev->udev->product);
+                               hif_dev->udev->product, id->driver_info);
        if (ret) {
                ret = -EINVAL;
                goto err_htc_hw_init;
 {
        struct hif_device_usb *hif_dev =
                (struct hif_device_usb *) usb_get_intfdata(interface);
+       struct htc_target *htc_handle = hif_dev->htc_handle;
        int ret;
 
        ret = ath9k_hif_usb_alloc_urbs(hif_dev);
                return ret;
 
        if (hif_dev->firmware) {
-               ret = ath9k_hif_usb_download_fw(hif_dev);
+               ret = ath9k_hif_usb_download_fw(hif_dev,
+                               htc_handle->drv_priv->ah->common.driver_info);
                if (ret)
                        goto fail_resume;
        } else {
 
        mdelay(100);
 
-       ret = ath9k_htc_resume(hif_dev->htc_handle);
+       ret = ath9k_htc_resume(htc_handle);
 
        if (ret)
                goto fail_resume;
 
 void ath9k_deinit_leds(struct ath9k_htc_priv *priv);
 
 int ath9k_htc_probe_device(struct htc_target *htc_handle, struct device *dev,
-                          u16 devid, char *product);
+                          u16 devid, char *product, u32 drv_info);
 void ath9k_htc_disconnect_device(struct htc_target *htc_handle, bool hotunplug);
 #ifdef CONFIG_PM
 int ath9k_htc_resume(struct htc_target *htc_handle);
 
        return htc_connect_service(priv->htc, &req, ep_id);
 }
 
-static int ath9k_init_htc_services(struct ath9k_htc_priv *priv, u16 devid)
+static int ath9k_init_htc_services(struct ath9k_htc_priv *priv, u16 devid,
+                                  u32 drv_info)
 {
        int ret;
 
         * the HIF layer, shouldn't matter much.
         */
 
-       switch(devid) {
-       case 0x7010:
-       case 0x7015:
-       case 0x9018:
-       case 0xA704:
-       case 0x1200:
+       if (drv_info & AR7010_DEVICE)
                priv->htc->credits = 45;
-               break;
-       default:
+       else
                priv->htc->credits = 33;
-       }
 
        ret = htc_init(priv->htc);
        if (ret)
 }
 
 static int ath9k_init_priv(struct ath9k_htc_priv *priv,
-                          u16 devid, char *product)
+                          u16 devid, char *product,
+                          u32 drv_info)
 {
        struct ath_hw *ah = NULL;
        struct ath_common *common;
        common->hw = priv->hw;
        common->priv = priv;
        common->debug_mask = ath9k_debug;
+       common->driver_info = drv_info;
 
        spin_lock_init(&priv->wmi->wmi_lock);
        spin_lock_init(&priv->beacon_lock);
 }
 
 static int ath9k_init_device(struct ath9k_htc_priv *priv,
-                            u16 devid, char *product)
+                            u16 devid, char *product, u32 drv_info)
 {
        struct ieee80211_hw *hw = priv->hw;
        struct ath_common *common;
        struct ath_regulatory *reg;
 
        /* Bring up device */
-       error = ath9k_init_priv(priv, devid, product);
+       error = ath9k_init_priv(priv, devid, product, drv_info);
        if (error != 0)
                goto err_init;
 
 }
 
 int ath9k_htc_probe_device(struct htc_target *htc_handle, struct device *dev,
-                          u16 devid, char *product)
+                          u16 devid, char *product, u32 drv_info)
 {
        struct ieee80211_hw *hw;
        struct ath9k_htc_priv *priv;
                goto err_free;
        }
 
-       ret = ath9k_init_htc_services(priv, devid);
+       ret = ath9k_init_htc_services(priv, devid, drv_info);
        if (ret)
                goto err_init;
 
        /* The device may have been unplugged earlier. */
        priv->op_flags &= ~OP_UNPLUGGED;
 
-       ret = ath9k_init_device(priv, devid, product);
+       ret = ath9k_init_device(priv, devid, product, drv_info);
        if (ret)
                goto err_init;
 
 #ifdef CONFIG_PM
 int ath9k_htc_resume(struct htc_target *htc_handle)
 {
+       struct ath9k_htc_priv *priv = htc_handle->drv_priv;
        int ret;
 
-       ret = ath9k_htc_wait_for_target(htc_handle->drv_priv);
+       ret = ath9k_htc_wait_for_target(priv);
        if (ret)
                return ret;
 
-       ret = ath9k_init_htc_services(htc_handle->drv_priv,
-                             htc_handle->drv_priv->ah->hw_version.devid);
+       ret = ath9k_init_htc_services(priv, priv->ah->hw_version.devid,
+                                     priv->ah->common.driver_info);
        return ret;
 }
 #endif
 
 }
 
 int ath9k_htc_hw_init(struct htc_target *target,
-                     struct device *dev, u16 devid, char *product)
+                     struct device *dev, u16 devid,
+                     char *product, u32 drv_info)
 {
-       if (ath9k_htc_probe_device(target, dev, devid, product)) {
+       if (ath9k_htc_probe_device(target, dev, devid, product, drv_info)) {
                printk(KERN_ERR "Failed to initialize the device\n");
                return -ENODEV;
        }
 
                                      struct device *dev);
 void ath9k_htc_hw_free(struct htc_target *htc);
 int ath9k_htc_hw_init(struct htc_target *target,
-                     struct device *dev, u16 devid, char *product);
+                     struct device *dev, u16 devid, char *product,
+                     u32 drv_info);
 void ath9k_htc_hw_deinit(struct htc_target *target, bool hot_unplug);
 
 #endif /* HTC_HST_H */
 
      ((REG_READ(_ah, AR_AN_SYNTH9) & 0x7) == 0x1))
 
 #define AR_DEVID_7010(_ah) \
-       (((_ah)->hw_version.devid == 0x7010) || \
-        ((_ah)->hw_version.devid == 0x7015) || \
-        ((_ah)->hw_version.devid == 0x9018) || \
-        ((_ah)->hw_version.devid == 0xA704) || \
-        ((_ah)->hw_version.devid == 0x1200))
+       ((_ah)->common.driver_info & AR7010_DEVICE)
 
 #define AR_RADIO_SREV_MAJOR                   0xf0
 #define AR_RAD5133_SREV_MAJOR                 0xc0