.temperature = iwlagn_temperature,
 };
 
-static const struct iwl_ops iwl1000_ops = {
-       .lib = &iwl1000_lib,
-};
-
 static struct iwl_base_params iwl1000_base_params = {
        .num_of_queues = IWLAGN_NUM_QUEUES,
        .num_of_ampdu_queues = IWLAGN_NUM_AMPDU_QUEUES,
        .ucode_api_min = IWL1000_UCODE_API_MIN,                 \
        .eeprom_ver = EEPROM_1000_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_1000_TX_POWER_VERSION,       \
-       .ops = &iwl1000_ops,                                    \
+       .lib = &iwl1000_lib,                                    \
        .base_params = &iwl1000_base_params,                    \
        .led_mode = IWL_LED_BLINK
 
        .ucode_api_min = IWL100_UCODE_API_MIN,                  \
        .eeprom_ver = EEPROM_1000_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_1000_TX_POWER_VERSION,       \
-       .ops = &iwl1000_ops,                                    \
+       .lib = &iwl1000_lib,                                    \
        .base_params = &iwl1000_base_params,                    \
        .led_mode = IWL_LED_RF_STATE,                           \
        .rx_with_siso_diversity = true
 
        .temperature = iwlagn_temperature,
 };
 
-static const struct iwl_ops iwl2000_ops = {
-       .lib = &iwl2000_lib,
-};
-
-static const struct iwl_ops iwl2030_ops = {
-       .lib = &iwl2030_lib,
-};
-
-static const struct iwl_ops iwl105_ops = {
-       .lib = &iwl2000_lib,
-};
-
-static const struct iwl_ops iwl135_ops = {
-       .lib = &iwl2030_lib,
-};
-
 static struct iwl_base_params iwl2000_base_params = {
        .eeprom_size = OTP_LOW_IMAGE_SIZE,
        .num_of_queues = IWLAGN_NUM_QUEUES,
        .ucode_api_min = IWL2000_UCODE_API_MIN,                 \
        .eeprom_ver = EEPROM_2000_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION,       \
-       .ops = &iwl2000_ops,                                    \
+       .lib = &iwl2000_lib,                                    \
        .base_params = &iwl2000_base_params,                    \
        .need_dc_calib = true,                                  \
        .need_temp_offset_calib = true,                         \
        .ucode_api_min = IWL2030_UCODE_API_MIN,                 \
        .eeprom_ver = EEPROM_2000_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION,       \
-       .ops = &iwl2030_ops,                                    \
+       .lib = &iwl2030_lib,                                    \
        .base_params = &iwl2030_base_params,                    \
        .bt_params = &iwl2030_bt_params,                        \
        .need_dc_calib = true,                                  \
        .ucode_api_min = IWL105_UCODE_API_MIN,                  \
        .eeprom_ver = EEPROM_2000_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION,       \
-       .ops = &iwl105_ops,                                     \
+       .lib = &iwl2000_lib,                                    \
        .base_params = &iwl2000_base_params,                    \
        .need_dc_calib = true,                                  \
        .need_temp_offset_calib = true,                         \
        .ucode_api_min = IWL135_UCODE_API_MIN,                  \
        .eeprom_ver = EEPROM_2000_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION,       \
-       .ops = &iwl135_ops,                                     \
+       .lib = &iwl2030_lib,                                    \
        .base_params = &iwl2030_base_params,                    \
        .bt_params = &iwl2030_bt_params,                        \
        .need_dc_calib = true,                                  \
 
        .temperature = iwl5150_temperature,
 };
 
-static const struct iwl_ops iwl5000_ops = {
-       .lib = &iwl5000_lib,
-};
-
-static const struct iwl_ops iwl5150_ops = {
-       .lib = &iwl5150_lib,
-};
-
 static struct iwl_base_params iwl5000_base_params = {
        .eeprom_size = IWLAGN_EEPROM_IMG_SIZE,
        .num_of_queues = IWLAGN_NUM_QUEUES,
        .ucode_api_min = IWL5000_UCODE_API_MIN,                 \
        .eeprom_ver = EEPROM_5000_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,       \
-       .ops = &iwl5000_ops,                                    \
+       .lib = &iwl5000_lib,                                    \
        .base_params = &iwl5000_base_params,                    \
        .led_mode = IWL_LED_BLINK
 
        .ucode_api_min = IWL5000_UCODE_API_MIN,
        .eeprom_ver = EEPROM_5050_EEPROM_VERSION,
        .eeprom_calib_ver = EEPROM_5050_TX_POWER_VERSION,
-       .ops = &iwl5000_ops,
+       .lib = &iwl5000_lib,
        .base_params = &iwl5000_base_params,
        .ht_params = &iwl5000_ht_params,
        .led_mode = IWL_LED_BLINK,
        .ucode_api_min = IWL5150_UCODE_API_MIN,                 \
        .eeprom_ver = EEPROM_5050_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_5050_TX_POWER_VERSION,       \
-       .ops = &iwl5150_ops,                                    \
+       .lib = &iwl5150_lib,                                    \
        .base_params = &iwl5000_base_params,                    \
        .need_dc_calib = true,                                  \
        .led_mode = IWL_LED_BLINK,                              \
 
                             CSR_GP_DRIVER_REG_BIT_RADIO_SKU_2x2_IPA);
        }
        /* do additional nic configuration if needed */
-       if (priv->cfg->ops->nic &&
-               priv->cfg->ops->nic->additional_nic_config) {
-                       priv->cfg->ops->nic->additional_nic_config(priv);
+       if (priv->cfg->nic &&
+               priv->cfg->nic->additional_nic_config) {
+                       priv->cfg->nic->additional_nic_config(priv);
        }
 }
 
        .additional_nic_config = &iwl6150_additional_nic_config,
 };
 
-static const struct iwl_ops iwl6000_ops = {
-       .lib = &iwl6000_lib,
-};
-
-static const struct iwl_ops iwl6050_ops = {
-       .lib = &iwl6000_lib,
-       .nic = &iwl6050_nic_ops,
-};
-
-static const struct iwl_ops iwl6150_ops = {
-       .lib = &iwl6000_lib,
-       .nic = &iwl6150_nic_ops,
-};
-
-static const struct iwl_ops iwl6030_ops = {
-       .lib = &iwl6030_lib,
-};
-
 static struct iwl_base_params iwl6000_base_params = {
        .eeprom_size = OTP_LOW_IMAGE_SIZE,
        .num_of_queues = IWLAGN_NUM_QUEUES,
        .ucode_api_min = IWL6000G2_UCODE_API_MIN,               \
        .eeprom_ver = EEPROM_6005_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_6005_TX_POWER_VERSION,       \
-       .ops = &iwl6000_ops,                                    \
+       .lib = &iwl6000_lib,                                    \
        .base_params = &iwl6000_g2_base_params,                 \
        .need_dc_calib = true,                                  \
        .need_temp_offset_calib = true,                         \
        .ucode_api_min = IWL6000G2_UCODE_API_MIN,               \
        .eeprom_ver = EEPROM_6030_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_6030_TX_POWER_VERSION,       \
-       .ops = &iwl6030_ops,                                    \
+       .lib = &iwl6030_lib,                                    \
        .base_params = &iwl6000_g2_base_params,                 \
        .bt_params = &iwl6000_bt_params,                        \
        .need_dc_calib = true,                                  \
        .valid_rx_ant = ANT_BC,         /* .cfg overwrite */    \
        .eeprom_ver = EEPROM_6000_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION,       \
-       .ops = &iwl6000_ops,                                    \
+       .lib = &iwl6000_lib,                                    \
        .base_params = &iwl6000_base_params,                    \
        .pa_type = IWL_PA_INTERNAL,                             \
        .led_mode = IWL_LED_BLINK
        .ucode_api_min = IWL6050_UCODE_API_MIN,                 \
        .valid_tx_ant = ANT_AB,         /* .cfg overwrite */    \
        .valid_rx_ant = ANT_AB,         /* .cfg overwrite */    \
-       .ops = &iwl6050_ops,                                    \
+       .lib = &iwl6000_lib,                                    \
+       .nic = &iwl6050_nic_ops,                                \
        .eeprom_ver = EEPROM_6050_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_6050_TX_POWER_VERSION,       \
        .base_params = &iwl6050_base_params,                    \
        .fw_name_pre = IWL6050_FW_PRE,                          \
        .ucode_api_max = IWL6050_UCODE_API_MAX,                 \
        .ucode_api_min = IWL6050_UCODE_API_MIN,                 \
-       .ops = &iwl6150_ops,                                    \
+       .lib = &iwl6000_lib,                                    \
+       .nic = &iwl6150_nic_ops,                                \
        .eeprom_ver = EEPROM_6150_EEPROM_VERSION,               \
        .eeprom_calib_ver = EEPROM_6150_TX_POWER_VERSION,       \
        .base_params = &iwl6050_base_params,                    \
        .ucode_api_min = IWL6000_UCODE_API_MIN,
        .eeprom_ver = EEPROM_6000_EEPROM_VERSION,
        .eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION,
-       .ops = &iwl6000_ops,
+       .lib = &iwl6000_lib,
        .base_params = &iwl6000_base_params,
        .ht_params = &iwl6000_ht_params,
        .need_dc_calib = true,
 
 
        iwlagn_set_pwr_vmain(priv);
 
-       priv->cfg->ops->lib->nic_config(priv);
+       priv->cfg->lib->nic_config(priv);
 
        /* Allocate the RX queue, or reset if it is already allocated */
        trans_rx_init(priv);
 
        u32 next_entry; /* index of next entry to be written by uCode */
 
        base = priv->device_pointers.error_event_table;
-       if (priv->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
+       if (priv->cfg->lib->is_valid_rtc_data_addr(base)) {
                capacity = iwl_read_targ_mem(priv, base);
                num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32)));
                mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32)));
                        base = priv->_agn.inst_errlog_ptr;
        }
 
-       if (!priv->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
+       if (!priv->cfg->lib->is_valid_rtc_data_addr(base)) {
                IWL_ERR(priv,
                        "Not valid error log pointer 0x%08X for %s uCode\n",
                        base,
                        base = priv->_agn.inst_evtlog_ptr;
        }
 
-       if (!priv->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
+       if (!priv->cfg->lib->is_valid_rtc_data_addr(base)) {
                IWL_ERR(priv,
                        "Invalid event log pointer 0x%08X for %s uCode\n",
                        base,
        if (!iwl_is_associated_ctx(ctx))
                goto out;
 
-       if (!priv->cfg->ops->lib->set_channel_switch)
+       if (!priv->cfg->lib->set_channel_switch)
                goto out;
 
        ch = channel->hw_value;
         */
        set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
        priv->switch_channel = cpu_to_le16(ch);
-       if (priv->cfg->ops->lib->set_channel_switch(priv, ch_switch)) {
+       if (priv->cfg->lib->set_channel_switch(priv, ch_switch)) {
                clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
                priv->switch_channel = 0;
                ieee80211_chswitch_done(ctx->vif, false);
 
        iwl_setup_scan_deferred_work(priv);
 
-       if (priv->cfg->ops->lib->setup_deferred_work)
-               priv->cfg->ops->lib->setup_deferred_work(priv);
+       if (priv->cfg->lib->setup_deferred_work)
+               priv->cfg->lib->setup_deferred_work(priv);
 
        init_timer(&priv->statistics_periodic);
        priv->statistics_periodic.data = (unsigned long)priv;
 
 static void iwl_cancel_deferred_work(struct iwl_priv *priv)
 {
-       if (priv->cfg->ops->lib->cancel_deferred_work)
-               priv->cfg->ops->lib->cancel_deferred_work(priv);
+       if (priv->cfg->lib->cancel_deferred_work)
+               priv->cfg->lib->cancel_deferred_work(priv);
 
        cancel_work_sync(&priv->run_time_calib_work);
        cancel_work_sync(&priv->beacon_update);
                priv->cfg->sku &= ~EEPROM_SKU_CAP_11N_ENABLE;
 
        /* Device-specific setup */
-       return priv->cfg->ops->lib->set_hw_params(priv);
+       return priv->cfg->lib->set_hw_params(priv);
 }
 
 static const u8 iwlagn_bss_ac_to_fifo[] = {
 
        void (*additional_nic_config)(struct iwl_priv *priv);
 };
 
-struct iwl_ops {
-       const struct iwl_lib_ops *lib;
-       const struct iwl_nic_ops *nic;
-};
-
 struct iwl_mod_params {
        int sw_crypto;          /* def: 0 = using hardware encryption */
        int num_of_queues;      /* def: HW dependent */
        u16  sku;
        u16  eeprom_ver;
        u16  eeprom_calib_ver;
-       const struct iwl_ops *ops;
+       const struct iwl_lib_ops *lib;
+       const struct iwl_nic_ops *nic;
        /* params not likely to change within a device family */
        struct iwl_base_params *base_params;
        /* params likely to change within a device family */
 
                        const struct iwl_eeprom_channel **eeprom_ch_info,
                        const u8 **eeprom_ch_index)
 {
-       u32 offset = priv->cfg->ops->lib->
+       u32 offset = priv->cfg->lib->
                        eeprom_ops.regulatory_bands[eep_band - 1];
        switch (eep_band) {
        case 1:         /* 2.4GHz band */
        }
 
        /* Check if we do have HT40 channels */
-       if (priv->cfg->ops->lib->eeprom_ops.regulatory_bands[5] ==
+       if (priv->cfg->lib->eeprom_ops.regulatory_bands[5] ==
            EEPROM_REGULATORY_BAND_NO_HT40 &&
-           priv->cfg->ops->lib->eeprom_ops.regulatory_bands[6] ==
+           priv->cfg->lib->eeprom_ops.regulatory_bands[6] ==
            EEPROM_REGULATORY_BAND_NO_HT40)
                return 0;
 
         * driver need to process addition information
         * to determine the max channel tx power limits
         */
-       if (priv->cfg->ops->lib->eeprom_ops.update_enhanced_txpower)
-               priv->cfg->ops->lib->eeprom_ops.update_enhanced_txpower(priv);
+       if (priv->cfg->lib->eeprom_ops.update_enhanced_txpower)
+               priv->cfg->lib->eeprom_ops.update_enhanced_txpower(priv);
 
        return 0;
 }
 
                iwl_rx_calc_noise(priv);
                queue_work(priv->workqueue, &priv->run_time_calib_work);
        }
-       if (priv->cfg->ops->lib->temperature && change)
-               priv->cfg->ops->lib->temperature(priv);
+       if (priv->cfg->lib->temperature && change)
+               priv->cfg->lib->temperature(priv);
 }
 
 static void iwl_rx_reply_statistics(struct iwl_priv *priv,
        handlers[REPLY_COMPRESSED_BA]           = iwlagn_rx_reply_compressed_ba;
 
        /* Set up hardware specific Rx handlers */
-       priv->cfg->ops->lib->rx_handler_setup(priv);
+       priv->cfg->lib->rx_handler_setup(priv);
 }
 
 void iwl_rx_dispatch(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)