int iwlagn_load_ucode_wait_alive(struct iwl_priv *priv,
                                 struct fw_img *image,
-                                int subtype, int alternate_subtype)
+                                enum iwlagn_ucode_type ucode_type)
 {
        struct iwl_notification_wait alive_wait;
        struct iwlagn_alive_data alive_data;
        int ret;
-       enum iwlagn_ucode_subtype old_type;
+       enum iwlagn_ucode_type old_type;
 
        ret = iwlagn_start_device(priv);
        if (ret)
                                      iwlagn_alive_fn, &alive_data);
 
        old_type = priv->ucode_type;
-       priv->ucode_type = subtype;
+       priv->ucode_type = ucode_type;
 
        ret = iwlagn_load_given_ucode(priv, image);
        if (ret) {
                return -EIO;
        }
 
-       if (alive_data.subtype != subtype &&
-           alive_data.subtype != alternate_subtype) {
-               IWL_ERR(priv,
-                       "Loaded ucode is not expected type (got %d, expected %d)!\n",
-                       alive_data.subtype, subtype);
-               priv->ucode_type = old_type;
-               return -EIO;
-       }
-
        ret = iwl_verify_ucode(priv, image);
        if (ret) {
                priv->ucode_type = old_type;
        if (!priv->ucode_init.code.len)
                return 0;
 
-       if (priv->ucode_type != UCODE_SUBTYPE_NONE_LOADED)
+       if (priv->ucode_type != IWL_UCODE_NONE)
                return 0;
 
        iwlagn_init_notification_wait(priv, &calib_wait,
 
        /* Will also start the device */
        ret = iwlagn_load_ucode_wait_alive(priv, &priv->ucode_init,
-                                          UCODE_SUBTYPE_INIT, -1);
+                                          IWL_UCODE_INIT);
        if (ret)
                goto error;
 
 
        struct iwl_error_event_table table;
 
        base = priv->device_pointers.error_event_table;
-       if (priv->ucode_type == UCODE_SUBTYPE_INIT) {
+       if (priv->ucode_type == IWL_UCODE_INIT) {
                if (!base)
                        base = priv->_agn.init_errlog_ptr;
        } else {
                IWL_ERR(priv,
                        "Not valid error log pointer 0x%08X for %s uCode\n",
                        base,
-                       (priv->ucode_type == UCODE_SUBTYPE_INIT)
+                       (priv->ucode_type == IWL_UCODE_INIT)
                                        ? "Init" : "RT");
                return;
        }
                return pos;
 
        base = priv->device_pointers.log_event_table;
-       if (priv->ucode_type == UCODE_SUBTYPE_INIT) {
+       if (priv->ucode_type == IWL_UCODE_INIT) {
                if (!base)
                        base = priv->_agn.init_evtlog_ptr;
        } else {
        size_t bufsz = 0;
 
        base = priv->device_pointers.log_event_table;
-       if (priv->ucode_type == UCODE_SUBTYPE_INIT) {
+       if (priv->ucode_type == IWL_UCODE_INIT) {
                logsize = priv->_agn.init_evtlog_size;
                if (!base)
                        base = priv->_agn.init_evtlog_ptr;
                IWL_ERR(priv,
                        "Invalid event log pointer 0x%08X for %s uCode\n",
                        base,
-                       (priv->ucode_type == UCODE_SUBTYPE_INIT)
+                       (priv->ucode_type == IWL_UCODE_INIT)
                                        ? "Init" : "RT");
                return -EINVAL;
        }
 
        ret = iwlagn_load_ucode_wait_alive(priv,
                                           &priv->ucode_rt,
-                                          UCODE_SUBTYPE_REGULAR,
-                                          UCODE_SUBTYPE_REGULAR_NEW);
+                                          IWL_UCODE_REGULAR);
        if (ret) {
                IWL_ERR(priv, "Failed to start RT ucode: %d\n", ret);
                goto error;
        priv = hw->priv;
        /* At this point both hw and priv are allocated. */
 
-       priv->ucode_type = UCODE_SUBTYPE_NONE_LOADED;
-
        /*
         * The default context is always valid,
         * more may be discovered when firmware
 
 int iwlagn_run_init_ucode(struct iwl_priv *priv);
 int iwlagn_load_ucode_wait_alive(struct iwl_priv *priv,
                                 struct fw_img *image,
-                                int subtype, int alternate_subtype);
+                                enum iwlagn_ucode_type ucode_type);
 
 /* lib */
 void iwl_check_abort_status(struct iwl_priv *priv,
 
 
 #define UCODE_VALID_OK cpu_to_le32(0x1)
 
-enum iwlagn_ucode_subtype {
-       UCODE_SUBTYPE_REGULAR   = 0,
-       UCODE_SUBTYPE_REGULAR_NEW = 1,
-       UCODE_SUBTYPE_INIT      = 9,
-
-       /*
-        * Not a valid subtype, the ucode has just a u8, so
-        * we can use something > 0xff for this value.
-        */
-       UCODE_SUBTYPE_NONE_LOADED = 0x100,
-};
-
 /**
  * REPLY_ALIVE = 0x1 (response only, not a command)
  *
 
        /* default is to dump the entire data segment */
        if (!priv->dbgfs_sram_offset && !priv->dbgfs_sram_len) {
                priv->dbgfs_sram_offset = 0x800000;
-               if (priv->ucode_type == UCODE_SUBTYPE_INIT)
+               if (priv->ucode_type == IWL_UCODE_INIT)
                        priv->dbgfs_sram_len = priv->ucode_init.data.len;
                else
                        priv->dbgfs_sram_len = priv->ucode_rt.data.len;
 
        IWL_SCAN_OFFCH_TX,
 };
 
+enum iwlagn_ucode_type {
+       IWL_UCODE_NONE,
+       IWL_UCODE_REGULAR,
+       IWL_UCODE_INIT,
+       IWL_UCODE_WOWLAN,
+};
+
 #ifdef CONFIG_IWLWIFI_DEVICE_SVTOOL
 struct iwl_testmode_trace {
        u32 buff_size;
        struct fw_img ucode_rt;
        struct fw_img ucode_init;
 
-       enum iwlagn_ucode_subtype ucode_type;
+       enum iwlagn_ucode_type ucode_type;
        u8 ucode_write_complete;        /* the image write is complete */
        char firmware_name[25];
 
 
 
        case IWL_TM_CMD_APP2DEV_LOAD_INIT_FW:
                status = iwlagn_load_ucode_wait_alive(priv, &priv->ucode_init,
-                                          UCODE_SUBTYPE_INIT, -1);
+                                                     IWL_UCODE_INIT);
                if (status)
                        IWL_DEBUG_INFO(priv,
                                "Error loading init ucode: %d\n", status);
        case IWL_TM_CMD_APP2DEV_LOAD_RUNTIME_FW:
                status = iwlagn_load_ucode_wait_alive(priv,
                                           &priv->ucode_rt,
-                                          UCODE_SUBTYPE_REGULAR,
-                                          UCODE_SUBTYPE_REGULAR_NEW);
+                                          IWL_UCODE_REGULAR);
                if (status) {
                        IWL_DEBUG_INFO(priv,
                                "Error loading runtime ucode: %d\n", status);