Commit 4d69c752 authored by Stanislaw Gruszka's avatar Stanislaw Gruszka
Browse files

iwlegacy: rename REPLY_ to N_ or C_ 



Signed-off-by: default avatarStanislaw Gruszka <sgruszka@redhat.com>
parent db7746f7

drivers/net/wireless/iwlegacy/3945-mac.c

+31 −31
Original line number Diff line number Diff line
@@ -348,7 +348,7 @@ static int il3945_send_beacon_cmd(struct il_priv *il) 


	frame_size = il3945_hw_get_beacon_cmd(il, frame, rate);



	rc = il_send_cmd_pdu(il, REPLY_TX_BEACON, frame_size,

	rc = il_send_cmd_pdu(il, C_TX_BEACON, frame_size,

			      &frame->u.cmd[0]);



	il3945_free_frame(il, frame);
@@ -406,7 +406,7 @@ static void il3945_build_tx_cmd_hwcrypto(struct il_priv *il, 
}



/*

 * handle build REPLY_TX command notification.

 * handle build C_TX command notification.

 */

static void il3945_build_tx_cmd_basic(struct il_priv *il,

				  struct il_device_cmd *cmd,
@@ -460,7 +460,7 @@ static void il3945_build_tx_cmd_basic(struct il_priv *il, 
}



/*

 * start REPLY_TX command process

 * start C_TX command process

 */

static int il3945_tx_skb(struct il_priv *il, struct sk_buff *skb)

{
@@ -560,7 +560,7 @@ static int il3945_tx_skb(struct il_priv *il, struct sk_buff *skb) 
	 * after Tx, uCode's Tx response will return this value so driver can

	 * locate the frame within the tx queue and do post-tx processing.

	 */

	out_cmd->hdr.cmd = REPLY_TX;

	out_cmd->hdr.cmd = C_TX;

	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |

				IDX_TO_SEQ(q->write_ptr)));
@@ -672,7 +672,7 @@ static int il3945_get_measurement(struct il_priv *il, 
	struct il_spectrum_cmd spectrum;

	struct il_rx_pkt *pkt;

	struct il_host_cmd cmd = {

		.id = REPLY_SPECTRUM_MEASUREMENT_CMD,

		.id = C_SPECTRUM_MEASUREMENT,

		.data = (void *)&spectrum,

		.flags = CMD_WANT_SKB,

	};
@@ -717,7 +717,7 @@ static int il3945_get_measurement(struct il_priv *il, 


	pkt = (struct il_rx_pkt *)cmd.reply_page;

	if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {

		IL_ERR("Bad return from REPLY_RX_ON_ASSOC command\n");

		IL_ERR("Bad return from N_RX_ON_ASSOC command\n");

		rc = -EIO;

	}
@@ -786,7 +786,7 @@ static void il3945_rx_reply_add_sta(struct il_priv *il, 
	struct il_rx_pkt *pkt = rxb_addr(rxb);

#endif



	D_RX("Received REPLY_ADD_STA: 0x%02X\n", pkt->u.status);

	D_RX("Received C_ADD_STA: 0x%02X\n", pkt->u.status);

}



static void il3945_rx_beacon_notif(struct il_priv *il,
@@ -853,27 +853,27 @@ static void il3945_rx_card_state_notif(struct il_priv *il, 
 */

static void il3945_setup_rx_handlers(struct il_priv *il)

{

	il->rx_handlers[REPLY_ALIVE] = il3945_rx_reply_alive;

	il->rx_handlers[REPLY_ADD_STA] = il3945_rx_reply_add_sta;

	il->rx_handlers[REPLY_ERROR] = il_rx_reply_error;

	il->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = il_rx_csa;

	il->rx_handlers[SPECTRUM_MEASURE_NOTIFICATION] =

	il->rx_handlers[N_ALIVE] = il3945_rx_reply_alive;

	il->rx_handlers[C_ADD_STA] = il3945_rx_reply_add_sta;

	il->rx_handlers[N_ERROR] = il_rx_reply_error;

	il->rx_handlers[N_CHANNEL_SWITCH] = il_rx_csa;

	il->rx_handlers[N_SPECTRUM_MEASUREMENT] =

			il_rx_spectrum_measure_notif;

	il->rx_handlers[PM_SLEEP_NOTIFICATION] = il_rx_pm_sleep_notif;

	il->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =

	il->rx_handlers[N_PM_SLEEP] = il_rx_pm_sleep_notif;

	il->rx_handlers[N_PM_DEBUG_STATS] =

	    il_rx_pm_debug_stats_notif;

	il->rx_handlers[BEACON_NOTIFICATION] = il3945_rx_beacon_notif;

	il->rx_handlers[N_BEACON] = il3945_rx_beacon_notif;



	/*

	 * The same handler is used for both the REPLY to a discrete

	 * stats request from the host as well as for the periodic

	 * stats notifications (after received beacons) from the uCode.

	 */

	il->rx_handlers[REPLY_STATS_CMD] = il3945_reply_stats;

	il->rx_handlers[STATS_NOTIFICATION] = il3945_hw_rx_stats;

	il->rx_handlers[C_STATS] = il3945_reply_stats;

	il->rx_handlers[N_STATS] = il3945_hw_rx_stats;



	il_setup_rx_scan_handlers(il);

	il->rx_handlers[CARD_STATE_NOTIFICATION] = il3945_rx_card_state_notif;

	il->rx_handlers[N_CARD_STATE] = il3945_rx_card_state_notif;



	/* Set up hardware specific Rx handlers */

	il3945_hw_rx_handler_setup(il);
@@ -1253,8 +1253,8 @@ static void il3945_rx_handle(struct il_priv *il) 
		 * Ucode should set SEQ_RX_FRAME bit if ucode-originated,

		 *   but apparently a few don't get set; catch them here. */

		reclaim = !(pkt->hdr.sequence & SEQ_RX_FRAME) &&

			pkt->hdr.cmd != STATS_NOTIFICATION &&

			pkt->hdr.cmd != REPLY_TX;

			pkt->hdr.cmd != N_STATS &&

			pkt->hdr.cmd != C_TX;



		/* Based on type of command response or notification,

		 *   handle those that need handling via function in
@@ -2137,9 +2137,9 @@ static int il3945_set_ucode_ptrs(struct il_priv *il) 
}



/**

 * il3945_init_alive_start - Called after REPLY_ALIVE notification received

 * il3945_init_alive_start - Called after N_ALIVE notification received

 *

 * Called after REPLY_ALIVE notification received from "initialize" uCode.

 * Called after N_ALIVE notification received from "initialize" uCode.

 *

 * Tell "initialize" uCode to go ahead and load the runtime uCode.

 */
@@ -2180,7 +2180,7 @@ static void il3945_init_alive_start(struct il_priv *il) 
}



/**

 * il3945_alive_start - called after REPLY_ALIVE notification received

 * il3945_alive_start - called after N_ALIVE notification received

 *                   from protocol/runtime uCode (initialization uCode's

 *                   Alive gets handled by il3945_init_alive_start()).

 */
@@ -2553,7 +2553,7 @@ static void il3945_rfkill_poll(struct work_struct *data) 
int il3945_request_scan(struct il_priv *il, struct ieee80211_vif *vif)

{

	struct il_host_cmd cmd = {

		.id = REPLY_SCAN_CMD,

		.id = C_SCAN,

		.len = sizeof(struct il3945_scan_cmd),

		.flags = CMD_SIZE_HUGE,

	};
@@ -2767,7 +2767,7 @@ void il3945_post_associate(struct il_priv *il) 


	rc = il_send_rxon_timing(il, ctx);

	if (rc)

		IL_WARN("REPLY_RXON_TIMING failed - "

		IL_WARN("C_RXON_TIMING failed - "

			    "Attempting to continue.\n");



	ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
@@ -2931,7 +2931,7 @@ void il3945_config_ap(struct il_priv *il) 
		/* RXON Timing */

		rc = il_send_rxon_timing(il, ctx);

		if (rc)

			IL_WARN("REPLY_RXON_TIMING failed - "

			IL_WARN("C_RXON_TIMING failed - "

					"Attempting to continue.\n");



		ctx->staging.assoc_id = 0;
@@ -3657,12 +3657,12 @@ static int il3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *en 


	il->ctx.ctxid = 0;



	il->ctx.rxon_cmd = REPLY_RXON;

	il->ctx.rxon_timing_cmd = REPLY_RXON_TIMING;

	il->ctx.rxon_assoc_cmd = REPLY_RXON_ASSOC;

	il->ctx.qos_cmd = REPLY_QOS_PARAM;

	il->ctx.rxon_cmd = C_RXON;

	il->ctx.rxon_timing_cmd = C_RXON_TIMING;

	il->ctx.rxon_assoc_cmd = C_RXON_ASSOC;

	il->ctx.qos_cmd = C_QOS_PARAM;

	il->ctx.ap_sta_id = IL_AP_ID;

	il->ctx.wep_key_cmd = REPLY_WEPKEY;

	il->ctx.wep_key_cmd = C_WEPKEY;

	il->ctx.interface_modes =

		BIT(NL80211_IFTYPE_STATION) |

		BIT(NL80211_IFTYPE_ADHOC);

drivers/net/wireless/iwlegacy/3945.c

+12 −12
Original line number Diff line number Diff line
@@ -53,7 +53,7 @@ static int il3945_send_led_cmd(struct il_priv *il, 
				struct il_led_cmd *led_cmd)

{

	struct il_host_cmd cmd = {

		.id = REPLY_LEDS_CMD,

		.id = C_LEDS,

		.len = sizeof(struct il_led_cmd),

		.data = led_cmd,

		.flags = CMD_ASYNC,
@@ -1444,7 +1444,7 @@ static int il3945_send_tx_power(struct il_priv *il) 
				txpower.power[i].rate);

	}



	return il_send_cmd_pdu(il, REPLY_TX_PWR_TBL_CMD,

	return il_send_cmd_pdu(il, C_TX_PWR_TBL,

				sizeof(struct il3945_txpowertable_cmd),

				&txpower);
@@ -1673,7 +1673,7 @@ static int il3945_send_rxon_assoc(struct il_priv *il, 
	struct il_rx_pkt *pkt;

	struct il3945_rxon_assoc_cmd rxon_assoc;

	struct il_host_cmd cmd = {

		.id = REPLY_RXON_ASSOC,

		.id = C_RXON_ASSOC,

		.len = sizeof(rxon_assoc),

		.flags = CMD_WANT_SKB,

		.data = &rxon_assoc,
@@ -1701,7 +1701,7 @@ static int il3945_send_rxon_assoc(struct il_priv *il, 


	pkt = (struct il_rx_pkt *)cmd.reply_page;

	if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {

		IL_ERR("Bad return from REPLY_RXON_ASSOC command\n");

		IL_ERR("Bad return from C_RXON_ASSOC command\n");

		rc = -EIO;

	}
@@ -1782,7 +1782,7 @@ int il3945_commit_rxon(struct il_priv *il, struct il_rxon_context *ctx) 
		 */

		active_rxon->reserved4 = 0;

		active_rxon->reserved5 = 0;

		rc = il_send_cmd_pdu(il, REPLY_RXON,

		rc = il_send_cmd_pdu(il, C_RXON,

				      sizeof(struct il3945_rxon_cmd),

				      &il->ctx.active);
@@ -1818,7 +1818,7 @@ int il3945_commit_rxon(struct il_priv *il, struct il_rxon_context *ctx) 
	il_set_rxon_hwcrypto(il, ctx, !il3945_mod_params.sw_crypto);



	/* Apply the new configuration */

	rc = il_send_cmd_pdu(il, REPLY_RXON,

	rc = il_send_cmd_pdu(il, C_RXON,

			      sizeof(struct il3945_rxon_cmd),

			      staging_rxon);

	if (rc) {
@@ -2237,9 +2237,9 @@ int il3945_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq) 
static u16 il3945_get_hcmd_size(u8 cmd_id, u16 len)

{

	switch (cmd_id) {

	case REPLY_RXON:

	case C_RXON:

		return sizeof(struct il3945_rxon_cmd);

	case POWER_TBL_CMD:

	case C_POWER_TBL:

		return sizeof(struct il3945_powertable_cmd);

	default:

		return len;
@@ -2383,14 +2383,14 @@ int il3945_init_hw_rate_table(struct il_priv *il) 


	/* Update the rate scaling for control frame Tx */

	rate_cmd.table_id = 0;

	rc = il_send_cmd_pdu(il, REPLY_RATE_SCALE, sizeof(rate_cmd),

	rc = il_send_cmd_pdu(il, C_RATE_SCALE, sizeof(rate_cmd),

			      &rate_cmd);

	if (rc)

		return rc;



	/* Update the rate scaling for data frame Tx */

	rate_cmd.table_id = 1;

	return il_send_cmd_pdu(il, REPLY_RATE_SCALE, sizeof(rate_cmd),

	return il_send_cmd_pdu(il, C_RATE_SCALE, sizeof(rate_cmd),

				&rate_cmd);

}
@@ -2464,8 +2464,8 @@ unsigned int il3945_hw_get_beacon_cmd(struct il_priv *il, 


void il3945_hw_rx_handler_setup(struct il_priv *il)

{

	il->rx_handlers[REPLY_TX] = il3945_rx_reply_tx;

	il->rx_handlers[REPLY_3945_RX] = il3945_rx_reply_rx;

	il->rx_handlers[C_TX] = il3945_rx_reply_tx;

	il->rx_handlers[N_3945_RX] = il3945_rx_reply_rx;

}



void il3945_hw_setup_deferred_work(struct il_priv *il)

drivers/net/wireless/iwlegacy/4965-calib.c

+6 −6
Original line number Diff line number Diff line
@@ -410,13 +410,13 @@ static void il4965_prepare_legacy_sensitivity_tbl(struct il_priv *il, 
			data->nrg_th_cck);

}



/* Prepare a SENSITIVITY_CMD, send to uCode if values have changed */

/* Prepare a C_SENSITIVITY, send to uCode if values have changed */

static int il4965_sensitivity_write(struct il_priv *il)

{

	struct il_sensitivity_cmd cmd;

	struct il_sensitivity_data *data = NULL;

	struct il_host_cmd cmd_out = {

		.id = SENSITIVITY_CMD,

		.id = C_SENSITIVITY,

		.len = sizeof(struct il_sensitivity_cmd),

		.flags = CMD_ASYNC,

		.data = &cmd,
@@ -429,12 +429,12 @@ static int il4965_sensitivity_write(struct il_priv *il) 
	il4965_prepare_legacy_sensitivity_tbl(il, data, &cmd.table[0]);



	/* Update uCode's "work" table, and copy it to DSP */

	cmd.control = SENSITIVITY_CMD_CONTROL_WORK_TBL;

	cmd.control = C_SENSITIVITY_CONTROL_WORK_TBL;



	/* Don't send command to uCode if nothing has changed */

	if (!memcmp(&cmd.table[0], &(il->sensitivity_tbl[0]),

		    sizeof(u16)*HD_TBL_SIZE)) {

		D_CALIB("No change in SENSITIVITY_CMD\n");

		D_CALIB("No change in C_SENSITIVITY\n");

		return 0;

	}
@@ -776,11 +776,11 @@ static void il4965_gain_computation(struct il_priv *il, 
		cmd.diff_gain_a = data->delta_gain_code[0];

		cmd.diff_gain_b = data->delta_gain_code[1];

		cmd.diff_gain_c = data->delta_gain_code[2];

		ret = il_send_cmd_pdu(il, REPLY_PHY_CALIBRATION_CMD,

		ret = il_send_cmd_pdu(il, C_PHY_CALIBRATION,

				      sizeof(cmd), &cmd);

		if (ret)

			D_CALIB("fail sending cmd "

				     "REPLY_PHY_CALIBRATION_CMD\n");

				     "C_PHY_CALIBRATION\n");



		/* TODO we might want recalculate

		 * rx_chain in rxon cmd */

drivers/net/wireless/iwlegacy/4965-mac.c

+48 −48
Original line number Diff line number Diff line
@@ -608,8 +608,8 @@ static void il4965_pass_packet_to_mac80211(struct il_priv *il, 
	rxb->page = NULL;

}



/* Called for REPLY_RX (legacy ABG frames), or

 * REPLY_RX_MPDU_CMD (HT high-throughput N frames). */

/* Called for N_RX (legacy ABG frames), or

 * N_RX_MPDU (HT high-throughput N frames). */

void il4965_rx_reply_rx(struct il_priv *il,

				struct il_rx_buf *rxb)

{
@@ -624,15 +624,15 @@ void il4965_rx_reply_rx(struct il_priv *il, 
	u32 rate_n_flags;



	/**

	 * REPLY_RX and REPLY_RX_MPDU_CMD are handled differently.

	 *	REPLY_RX: physical layer info is in this buffer

	 *	REPLY_RX_MPDU_CMD: physical layer info was sent in separate

	 * N_RX and N_RX_MPDU are handled differently.

	 *	N_RX: physical layer info is in this buffer

	 *	N_RX_MPDU: physical layer info was sent in separate

	 *		command and cached in il->last_phy_res

	 *

	 * Here we set up local variables depending on which command is

	 * received.

	 */

	if (pkt->hdr.cmd == REPLY_RX) {

	if (pkt->hdr.cmd == N_RX) {

		phy_res = (struct il_rx_phy_res *)pkt->u.raw;

		header = (struct ieee80211_hdr *)(pkt->u.raw + sizeof(*phy_res)

				+ phy_res->cfg_phy_cnt);
@@ -728,8 +728,8 @@ void il4965_rx_reply_rx(struct il_priv *il, 
				    rxb, &rx_status);

}



/* Cache phy data (Rx signal strength, etc) for HT frame (REPLY_RX_PHY_CMD).

 * This will be used later in il_rx_reply_rx() for REPLY_RX_MPDU_CMD. */

/* Cache phy data (Rx signal strength, etc) for HT frame (N_RX_PHY).

 * This will be used later in il_rx_reply_rx() for N_RX_MPDU. */

void il4965_rx_reply_rx_phy(struct il_priv *il,

			    struct il_rx_buf *rxb)

{
@@ -827,7 +827,7 @@ static inline u32 il4965_ant_idx_to_flags(u8 ant_idx) 
int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)

{

	struct il_host_cmd cmd = {

		.id = REPLY_SCAN_CMD,

		.id = C_SCAN,

		.len = sizeof(struct il_scan_cmd),

		.flags = CMD_SIZE_HUGE,

	};
@@ -1388,7 +1388,7 @@ void il4965_rx_stats(struct il_priv *il, 
		  msecs_to_jiffies(REG_RECALIB_PERIOD * 1000));



	if (unlikely(!test_bit(S_SCANNING, &il->status)) &&

	    (pkt->hdr.cmd == STATS_NOTIFICATION)) {

	    (pkt->hdr.cmd == N_STATS)) {

		il4965_rx_calc_noise(il);

		queue_work(il->workqueue, &il->run_time_calib_work);

	}
@@ -1473,7 +1473,7 @@ il4965_get_fifo_from_tid(struct il_rxon_context *ctx, u16 tid) 
}



/*

 * handle build REPLY_TX command notification.

 * handle build C_TX command notification.

 */

static void il4965_tx_cmd_build_basic(struct il_priv *il,

					struct sk_buff *skb,
@@ -1640,7 +1640,7 @@ static void il4965_tx_cmd_build_hwcrypto(struct il_priv *il, 
}



/*

 * start REPLY_TX command process

 * start C_TX command process

 */

int il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)

{
@@ -1797,7 +1797,7 @@ int il4965_tx_skb(struct il_priv *il, struct sk_buff *skb) 
	 * after Tx, uCode's Tx response will return this value so driver can

	 * locate the frame within the tx queue and do post-tx processing.

	 */

	out_cmd->hdr.cmd = REPLY_TX;

	out_cmd->hdr.cmd = C_TX;

	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |

				IDX_TO_SEQ(q->write_ptr)));
@@ -2616,7 +2616,7 @@ void il4965_hwrate_to_tx_control(struct il_priv *il, u32 rate_n_flags, 
}



/**

 * il4965_rx_reply_compressed_ba - Handler for REPLY_COMPRESSED_BA

 * il4965_rx_reply_compressed_ba - Handler for N_COMPRESSED_BA

 *

 * Handles block-acknowledge notification from device, which reports success

 * of frames sent via aggregation.
@@ -2668,7 +2668,7 @@ void il4965_rx_reply_compressed_ba(struct il_priv *il, 


	spin_lock_irqsave(&il->sta_lock, flags);



	D_TX_REPLY("REPLY_COMPRESSED_BA [%d] Received from %pM, "

	D_TX_REPLY("N_COMPRESSED_BA [%d] Received from %pM, "

			   "sta_id = %d\n",

			   agg->wait_for_ba,

			   (u8 *) &ba_resp->sta_addr_lo32,
@@ -2917,7 +2917,7 @@ int il4965_remove_default_wep_key(struct il_priv *il, 
	memset(&ctx->wep_keys[keyconf->keyidx], 0, sizeof(ctx->wep_keys[0]));

	if (il_is_rfkill(il)) {

		D_WEP(

		"Not sending REPLY_WEPKEY command due to RFKILL.\n");

		"Not sending C_WEPKEY command due to RFKILL.\n");

		/* but keys in device are clear anyway so return success */

		return 0;

	}
@@ -3201,7 +3201,7 @@ int il4965_remove_dynamic_key(struct il_priv *il, 


	if (il_is_rfkill(il)) {

		D_WEP(

		 "Not sending REPLY_ADD_STA command because RFKILL enabled.\n");

		 "Not sending C_ADD_STA command because RFKILL enabled.\n");

		spin_unlock_irqrestore(&il->sta_lock, flags);

		return 0;

	}
@@ -3598,7 +3598,7 @@ int il4965_send_beacon_cmd(struct il_priv *il) 
		return -EINVAL;

	}



	rc = il_send_cmd_pdu(il, REPLY_TX_BEACON, frame_size,

	rc = il_send_cmd_pdu(il, C_TX_BEACON, frame_size,

			      &frame->u.cmd[0]);



	il4965_free_frame(il, frame);
@@ -3801,7 +3801,7 @@ static void il4965_rx_reply_alive(struct il_priv *il, 
 * This callback is provided in order to send a stats request.

 *

 * This timer function is continually reset to execute within

 * REG_RECALIB_PERIOD seconds since the last STATS_NOTIFICATION

 * REG_RECALIB_PERIOD seconds since the last N_STATS

 * was received.  We need to ensure we receive the stats in order

 * to update the temperature used for calibrating the TXPOWER.

 */
@@ -3921,37 +3921,37 @@ static void il4965_rx_card_state_notif(struct il_priv *il, 
 */

static void il4965_setup_rx_handlers(struct il_priv *il)

{

	il->rx_handlers[REPLY_ALIVE] = il4965_rx_reply_alive;

	il->rx_handlers[REPLY_ERROR] = il_rx_reply_error;

	il->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = il_rx_csa;

	il->rx_handlers[SPECTRUM_MEASURE_NOTIFICATION] =

	il->rx_handlers[N_ALIVE] = il4965_rx_reply_alive;

	il->rx_handlers[N_ERROR] = il_rx_reply_error;

	il->rx_handlers[N_CHANNEL_SWITCH] = il_rx_csa;

	il->rx_handlers[N_SPECTRUM_MEASUREMENT] =

			il_rx_spectrum_measure_notif;

	il->rx_handlers[PM_SLEEP_NOTIFICATION] = il_rx_pm_sleep_notif;

	il->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =

	il->rx_handlers[N_PM_SLEEP] = il_rx_pm_sleep_notif;

	il->rx_handlers[N_PM_DEBUG_STATS] =

	    il_rx_pm_debug_stats_notif;

	il->rx_handlers[BEACON_NOTIFICATION] = il4965_rx_beacon_notif;

	il->rx_handlers[N_BEACON] = il4965_rx_beacon_notif;



	/*

	 * The same handler is used for both the REPLY to a discrete

	 * stats request from the host as well as for the periodic

	 * stats notifications (after received beacons) from the uCode.

	 */

	il->rx_handlers[REPLY_STATS_CMD] = il4965_reply_stats;

	il->rx_handlers[STATS_NOTIFICATION] = il4965_rx_stats;

	il->rx_handlers[C_STATS] = il4965_reply_stats;

	il->rx_handlers[N_STATS] = il4965_rx_stats;



	il_setup_rx_scan_handlers(il);



	/* status change handler */

	il->rx_handlers[CARD_STATE_NOTIFICATION] =

	il->rx_handlers[N_CARD_STATE] =

					il4965_rx_card_state_notif;



	il->rx_handlers[MISSED_BEACONS_NOTIFICATION] =

	il->rx_handlers[N_MISSED_BEACONS] =

	    il4965_rx_missed_beacon_notif;

	/* Rx handlers */

	il->rx_handlers[REPLY_RX_PHY_CMD] = il4965_rx_reply_rx_phy;

	il->rx_handlers[REPLY_RX_MPDU_CMD] = il4965_rx_reply_rx;

	il->rx_handlers[N_RX_PHY] = il4965_rx_reply_rx_phy;

	il->rx_handlers[N_RX_MPDU] = il4965_rx_reply_rx;

	/* block ack */

	il->rx_handlers[REPLY_COMPRESSED_BA] = il4965_rx_reply_compressed_ba;

	il->rx_handlers[N_COMPRESSED_BA] = il4965_rx_reply_compressed_ba;

	/* Set up hardware specific Rx handlers */

	il->cfg->ops->lib->rx_handler_setup(il);

}
@@ -4019,12 +4019,12 @@ void il4965_rx_handle(struct il_priv *il) 
		 * Ucode should set SEQ_RX_FRAME bit if ucode-originated,

		 *   but apparently a few don't get set; catch them here. */

		reclaim = !(pkt->hdr.sequence & SEQ_RX_FRAME) &&

			(pkt->hdr.cmd != REPLY_RX_PHY_CMD) &&

			(pkt->hdr.cmd != REPLY_RX) &&

			(pkt->hdr.cmd != REPLY_RX_MPDU_CMD) &&

			(pkt->hdr.cmd != REPLY_COMPRESSED_BA) &&

			(pkt->hdr.cmd != STATS_NOTIFICATION) &&

			(pkt->hdr.cmd != REPLY_TX);

			(pkt->hdr.cmd != N_RX_PHY) &&

			(pkt->hdr.cmd != N_RX) &&

			(pkt->hdr.cmd != N_RX_MPDU) &&

			(pkt->hdr.cmd != N_COMPRESSED_BA) &&

			(pkt->hdr.cmd != N_STATS) &&

			(pkt->hdr.cmd != C_TX);



		/* Based on type of command response or notification,

		 *   handle those that need handling via function in
@@ -4923,12 +4923,12 @@ static void il4965_rf_kill_ct_config(struct il_priv *il) 
	cmd.critical_temperature_R =

		cpu_to_le32(il->hw_params.ct_kill_threshold);



	ret = il_send_cmd_pdu(il, REPLY_CT_KILL_CONFIG_CMD,

	ret = il_send_cmd_pdu(il, C_CT_KILL_CONFIG,

			       sizeof(cmd), &cmd);

	if (ret)

		IL_ERR("REPLY_CT_KILL_CONFIG_CMD failed\n");

		IL_ERR("C_CT_KILL_CONFIG failed\n");

	else

		D_INFO("REPLY_CT_KILL_CONFIG_CMD "

		D_INFO("C_CT_KILL_CONFIG "

				"succeeded, "

				"critical temperature is %d\n",

				il->hw_params.ct_kill_threshold);
@@ -5042,7 +5042,7 @@ static int il4965_alive_notify(struct il_priv *il) 
}



/**

 * il4965_alive_start - called after REPLY_ALIVE notification received

 * il4965_alive_start - called after N_ALIVE notification received

 *                   from protocol/runtime uCode (initialization uCode's

 *                   Alive gets handled by il_init_alive_start()).

 */
@@ -6200,12 +6200,12 @@ il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 


	il->ctx.always_active = true;

	il->ctx.is_active = true;

	il->ctx.rxon_cmd = REPLY_RXON;

	il->ctx.rxon_timing_cmd = REPLY_RXON_TIMING;

	il->ctx.rxon_assoc_cmd = REPLY_RXON_ASSOC;

	il->ctx.qos_cmd = REPLY_QOS_PARAM;

	il->ctx.rxon_cmd = C_RXON;

	il->ctx.rxon_timing_cmd = C_RXON_TIMING;

	il->ctx.rxon_assoc_cmd = C_RXON_ASSOC;

	il->ctx.qos_cmd = C_QOS_PARAM;

	il->ctx.ap_sta_id = IL_AP_ID;

	il->ctx.wep_key_cmd = REPLY_WEPKEY;

	il->ctx.wep_key_cmd = C_WEPKEY;

	il->ctx.ac_to_fifo = il4965_bss_ac_to_fifo;

	il->ctx.ac_to_queue = il4965_bss_ac_to_queue;

	il->ctx.exclusive_interface_modes =

drivers/net/wireless/iwlegacy/4965-rs.c

+2 −2
Original line number Diff line number Diff line
@@ -2172,8 +2172,8 @@ static void il4965_rs_rate_scale_perform(struct il_priv *il, 
 *       if the driver's iwl-4965-rs rate scaling algorithm is used, instead of

 *       rc80211_simple.

 *

 * NOTE: Run REPLY_ADD_STA command to set up station table entry, before

 *       calling this function (which runs REPLY_TX_LINK_QUALITY_CMD,

 * NOTE: Run C_ADD_STA command to set up station table entry, before

 *       calling this function (which runs C_TX_LINK_QUALITY_CMD,

 *       which requires station table entry to exist).

 */

static void il4965_rs_initialize_lq(struct il_priv *il,