Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2437f3c5 authored by John W. Linville's avatar John W. Linville
Browse files

Merge branch 'for-john' of git://git.kernel.org/pub/scm/linux/kernel/git/iwlwifi/iwlwifi-next

parents 4f054448 ef4394b9

drivers/net/wireless/iwlwifi/iwl-op-mode.h

+2 −2
Original line number Diff line number Diff line
@@ -93,7 +93,7 @@ struct iwl_cfg; 
 *	1) The driver layer (iwl-drv.c) chooses the op_mode based on the

 *	   capabilities advertized by the fw file (in TLV format).

 *	2) The driver layer starts the op_mode (ops->start)

 *	3) The op_mode registers registers mac80211

 *	3) The op_mode registers mac80211

 *	4) The op_mode is governed by mac80211

 *	5) The driver layer stops the op_mode

 */
@@ -112,7 +112,7 @@ struct iwl_cfg; 
 * @stop: stop the op_mode. Must free all the memory allocated.

 *	May sleep

 * @rx: Rx notification to the op_mode. rxb is the Rx buffer itself. Cmd is the

 *	HCMD the this Rx responds to.

 *	HCMD this Rx responds to.

 *	This callback may sleep, it is called from a threaded IRQ handler.

 * @queue_full: notifies that a HW queue is full.

 *	Must be atomic and called with BH disabled.

drivers/net/wireless/iwlwifi/iwl-trans.h

+4 −21
Original line number Diff line number Diff line
@@ -180,7 +180,7 @@ struct iwl_rx_packet { 
 * enum CMD_MODE - how to send the host commands ?

 *

 * @CMD_SYNC: The caller will be stalled until the fw responds to the command

 * @CMD_ASYNC: Return right away and don't want for the response

 * @CMD_ASYNC: Return right away and don't wait for the response

 * @CMD_WANT_SKB: valid only with CMD_SYNC. The caller needs the buffer of the

 *	response. The caller needs to call iwl_free_resp when done.

 */
@@ -218,7 +218,7 @@ struct iwl_device_cmd { 
 *

 * @IWL_HCMD_DFL_NOCOPY: By default, the command is copied to the host command's

 *	ring. The transport layer doesn't map the command's buffer to DMA, but

 *	rather copies it to an previously allocated DMA buffer. This flag tells

 *	rather copies it to a previously allocated DMA buffer. This flag tells

 *	the transport layer not to copy the command, but to map the existing

 *	buffer (that is passed in) instead. This saves the memcpy and allows

 *	commands that are bigger than the fixed buffer to be submitted.
@@ -243,7 +243,7 @@ enum iwl_hcmd_dataflag { 
 * @handler_status: return value of the handler of the command

 *	(put in setup_rx_handlers) - valid for SYNC mode only

 * @flags: can be CMD_*

 * @len: array of the lenths of the chunks in data

 * @len: array of the lengths of the chunks in data

 * @dataflags: IWL_HCMD_DFL_*

 * @id: id of the host command

 */
@@ -396,8 +396,6 @@ struct iwl_trans; 
 *	May sleep

 * @dbgfs_register: add the dbgfs files under this directory. Files will be

 *	automatically deleted.

 * @suspend: stop the device unless WoWLAN is configured

 * @resume: resume activity of the device

 * @write8: write a u8 to a register at offset ofs from the BAR

 * @write32: write a u32 to a register at offset ofs from the BAR

 * @read32: read a u32 register at offset ofs from the BAR
@@ -443,10 +441,7 @@ struct iwl_trans_ops { 


	int (*dbgfs_register)(struct iwl_trans *trans, struct dentry* dir);

	int (*wait_tx_queue_empty)(struct iwl_trans *trans);

#ifdef CONFIG_PM_SLEEP

	int (*suspend)(struct iwl_trans *trans);

	int (*resume)(struct iwl_trans *trans);

#endif



	void (*write8)(struct iwl_trans *trans, u32 ofs, u8 val);

	void (*write32)(struct iwl_trans *trans, u32 ofs, u32 val);

	u32 (*read32)(struct iwl_trans *trans, u32 ofs);
@@ -700,18 +695,6 @@ static inline int iwl_trans_dbgfs_register(struct iwl_trans *trans, 
	return trans->ops->dbgfs_register(trans, dir);

}



#ifdef CONFIG_PM_SLEEP

static inline int iwl_trans_suspend(struct iwl_trans *trans)

{

	return trans->ops->suspend(trans);

}



static inline int iwl_trans_resume(struct iwl_trans *trans)

{

	return trans->ops->resume(trans);

}

#endif



static inline void iwl_trans_write8(struct iwl_trans *trans, u32 ofs, u8 val)

{

	trans->ops->write8(trans, ofs, val);

drivers/net/wireless/iwlwifi/mvm/debugfs.c

+138 −0
Original line number Diff line number Diff line
@@ -592,6 +592,142 @@ static ssize_t iwl_dbgfs_bt_notif_read(struct file *file, char __user *user_buf, 
}

#undef BT_MBOX_PRINT



#define PRINT_STATS_LE32(_str, _val)					\

			 pos += scnprintf(buf + pos, bufsz - pos,	\

					  fmt_table, _str,		\

					  le32_to_cpu(_val))



static ssize_t iwl_dbgfs_fw_rx_stats_read(struct file *file,

					  char __user *user_buf, size_t count,

					  loff_t *ppos)

{

	struct iwl_mvm *mvm = file->private_data;

	static const char *fmt_table = "\t%-30s %10u\n";

	static const char *fmt_header = "%-32s\n";

	int pos = 0;

	char *buf;

	int ret;

	int bufsz = sizeof(struct mvm_statistics_rx_phy) * 20 +

		    sizeof(struct mvm_statistics_rx_non_phy) * 10 +

		    sizeof(struct mvm_statistics_rx_ht_phy) * 10 + 200;

	struct mvm_statistics_rx_phy *ofdm;

	struct mvm_statistics_rx_phy *cck;

	struct mvm_statistics_rx_non_phy *general;

	struct mvm_statistics_rx_ht_phy *ht;



	buf = kzalloc(bufsz, GFP_KERNEL);

	if (!buf)

		return -ENOMEM;



	mutex_lock(&mvm->mutex);



	ofdm = &mvm->rx_stats.ofdm;

	cck = &mvm->rx_stats.cck;

	general = &mvm->rx_stats.general;

	ht = &mvm->rx_stats.ofdm_ht;



	pos += scnprintf(buf + pos, bufsz - pos, fmt_header,

			 "Statistics_Rx - OFDM");

	PRINT_STATS_LE32("ina_cnt", ofdm->ina_cnt);

	PRINT_STATS_LE32("fina_cnt", ofdm->fina_cnt);

	PRINT_STATS_LE32("plcp_err", ofdm->plcp_err);

	PRINT_STATS_LE32("crc32_err", ofdm->crc32_err);

	PRINT_STATS_LE32("overrun_err", ofdm->overrun_err);

	PRINT_STATS_LE32("early_overrun_err", ofdm->early_overrun_err);

	PRINT_STATS_LE32("crc32_good", ofdm->crc32_good);

	PRINT_STATS_LE32("false_alarm_cnt", ofdm->false_alarm_cnt);

	PRINT_STATS_LE32("fina_sync_err_cnt", ofdm->fina_sync_err_cnt);

	PRINT_STATS_LE32("sfd_timeout", ofdm->sfd_timeout);

	PRINT_STATS_LE32("fina_timeout", ofdm->fina_timeout);

	PRINT_STATS_LE32("unresponded_rts", ofdm->unresponded_rts);

	PRINT_STATS_LE32("rxe_frame_lmt_overrun",

			 ofdm->rxe_frame_limit_overrun);

	PRINT_STATS_LE32("sent_ack_cnt", ofdm->sent_ack_cnt);

	PRINT_STATS_LE32("sent_cts_cnt", ofdm->sent_cts_cnt);

	PRINT_STATS_LE32("sent_ba_rsp_cnt", ofdm->sent_ba_rsp_cnt);

	PRINT_STATS_LE32("dsp_self_kill", ofdm->dsp_self_kill);

	PRINT_STATS_LE32("mh_format_err", ofdm->mh_format_err);

	PRINT_STATS_LE32("re_acq_main_rssi_sum", ofdm->re_acq_main_rssi_sum);

	PRINT_STATS_LE32("reserved", ofdm->reserved);



	pos += scnprintf(buf + pos, bufsz - pos, fmt_header,

			 "Statistics_Rx - CCK");

	PRINT_STATS_LE32("ina_cnt", cck->ina_cnt);

	PRINT_STATS_LE32("fina_cnt", cck->fina_cnt);

	PRINT_STATS_LE32("plcp_err", cck->plcp_err);

	PRINT_STATS_LE32("crc32_err", cck->crc32_err);

	PRINT_STATS_LE32("overrun_err", cck->overrun_err);

	PRINT_STATS_LE32("early_overrun_err", cck->early_overrun_err);

	PRINT_STATS_LE32("crc32_good", cck->crc32_good);

	PRINT_STATS_LE32("false_alarm_cnt", cck->false_alarm_cnt);

	PRINT_STATS_LE32("fina_sync_err_cnt", cck->fina_sync_err_cnt);

	PRINT_STATS_LE32("sfd_timeout", cck->sfd_timeout);

	PRINT_STATS_LE32("fina_timeout", cck->fina_timeout);

	PRINT_STATS_LE32("unresponded_rts", cck->unresponded_rts);

	PRINT_STATS_LE32("rxe_frame_lmt_overrun",

			 cck->rxe_frame_limit_overrun);

	PRINT_STATS_LE32("sent_ack_cnt", cck->sent_ack_cnt);

	PRINT_STATS_LE32("sent_cts_cnt", cck->sent_cts_cnt);

	PRINT_STATS_LE32("sent_ba_rsp_cnt", cck->sent_ba_rsp_cnt);

	PRINT_STATS_LE32("dsp_self_kill", cck->dsp_self_kill);

	PRINT_STATS_LE32("mh_format_err", cck->mh_format_err);

	PRINT_STATS_LE32("re_acq_main_rssi_sum", cck->re_acq_main_rssi_sum);

	PRINT_STATS_LE32("reserved", cck->reserved);



	pos += scnprintf(buf + pos, bufsz - pos, fmt_header,

			 "Statistics_Rx - GENERAL");

	PRINT_STATS_LE32("bogus_cts", general->bogus_cts);

	PRINT_STATS_LE32("bogus_ack", general->bogus_ack);

	PRINT_STATS_LE32("non_bssid_frames", general->non_bssid_frames);

	PRINT_STATS_LE32("filtered_frames", general->filtered_frames);

	PRINT_STATS_LE32("non_channel_beacons", general->non_channel_beacons);

	PRINT_STATS_LE32("channel_beacons", general->channel_beacons);

	PRINT_STATS_LE32("num_missed_bcon", general->num_missed_bcon);

	PRINT_STATS_LE32("adc_rx_saturation_time",

			 general->adc_rx_saturation_time);

	PRINT_STATS_LE32("ina_detection_search_time",

			 general->ina_detection_search_time);

	PRINT_STATS_LE32("beacon_silence_rssi_a",

			 general->beacon_silence_rssi_a);

	PRINT_STATS_LE32("beacon_silence_rssi_b",

			 general->beacon_silence_rssi_b);

	PRINT_STATS_LE32("beacon_silence_rssi_c",

			 general->beacon_silence_rssi_c);

	PRINT_STATS_LE32("interference_data_flag",

			 general->interference_data_flag);

	PRINT_STATS_LE32("channel_load", general->channel_load);

	PRINT_STATS_LE32("dsp_false_alarms", general->dsp_false_alarms);

	PRINT_STATS_LE32("beacon_rssi_a", general->beacon_rssi_a);

	PRINT_STATS_LE32("beacon_rssi_b", general->beacon_rssi_b);

	PRINT_STATS_LE32("beacon_rssi_c", general->beacon_rssi_c);

	PRINT_STATS_LE32("beacon_energy_a", general->beacon_energy_a);

	PRINT_STATS_LE32("beacon_energy_b", general->beacon_energy_b);

	PRINT_STATS_LE32("beacon_energy_c", general->beacon_energy_c);

	PRINT_STATS_LE32("num_bt_kills", general->num_bt_kills);

	PRINT_STATS_LE32("directed_data_mpdu", general->directed_data_mpdu);



	pos += scnprintf(buf + pos, bufsz - pos, fmt_header,

			 "Statistics_Rx - HT");

	PRINT_STATS_LE32("plcp_err", ht->plcp_err);

	PRINT_STATS_LE32("overrun_err", ht->overrun_err);

	PRINT_STATS_LE32("early_overrun_err", ht->early_overrun_err);

	PRINT_STATS_LE32("crc32_good", ht->crc32_good);

	PRINT_STATS_LE32("crc32_err", ht->crc32_err);

	PRINT_STATS_LE32("mh_format_err", ht->mh_format_err);

	PRINT_STATS_LE32("agg_crc32_good", ht->agg_crc32_good);

	PRINT_STATS_LE32("agg_mpdu_cnt", ht->agg_mpdu_cnt);

	PRINT_STATS_LE32("agg_cnt", ht->agg_cnt);

	PRINT_STATS_LE32("unsupport_mcs", ht->unsupport_mcs);



	mutex_unlock(&mvm->mutex);



	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);

	kfree(buf);



	return ret;

}

#undef PRINT_STAT_LE32



static ssize_t iwl_dbgfs_fw_restart_write(struct file *file,

					  const char __user *user_buf,

					  size_t count, loff_t *ppos)
@@ -924,6 +1060,7 @@ MVM_DEBUGFS_READ_FILE_OPS(stations); 
MVM_DEBUGFS_READ_FILE_OPS(bt_notif);

MVM_DEBUGFS_WRITE_FILE_OPS(power_down_allow);

MVM_DEBUGFS_WRITE_FILE_OPS(power_down_d3_allow);

MVM_DEBUGFS_READ_FILE_OPS(fw_rx_stats);

MVM_DEBUGFS_WRITE_FILE_OPS(fw_restart);

#ifdef CONFIG_PM_SLEEP

MVM_DEBUGFS_READ_WRITE_FILE_OPS(d3_sram);
@@ -947,6 +1084,7 @@ int iwl_mvm_dbgfs_register(struct iwl_mvm *mvm, struct dentry *dbgfs_dir) 
	MVM_DEBUGFS_ADD_FILE(bt_notif, dbgfs_dir, S_IRUSR);

	MVM_DEBUGFS_ADD_FILE(power_down_allow, mvm->debugfs_dir, S_IWUSR);

	MVM_DEBUGFS_ADD_FILE(power_down_d3_allow, mvm->debugfs_dir, S_IWUSR);

	MVM_DEBUGFS_ADD_FILE(fw_rx_stats, mvm->debugfs_dir, S_IRUSR);

	MVM_DEBUGFS_ADD_FILE(fw_restart, mvm->debugfs_dir, S_IWUSR);

#ifdef CONFIG_PM_SLEEP

	MVM_DEBUGFS_ADD_FILE(d3_sram, mvm->debugfs_dir, S_IRUSR | S_IWUSR);

drivers/net/wireless/iwlwifi/mvm/mac80211.c

+11 −6
Original line number Diff line number Diff line
@@ -508,7 +508,7 @@ static int iwl_mvm_mac_add_interface(struct ieee80211_hw *hw, 


	mutex_lock(&mvm->mutex);



	/* Allocate resources for the MAC context, and add it the the fw  */

	/* Allocate resources for the MAC context, and add it to the fw  */

	ret = iwl_mvm_mac_ctxt_init(mvm, vif);

	if (ret)

		goto out_unlock;
@@ -569,6 +569,10 @@ static int iwl_mvm_mac_add_interface(struct ieee80211_hw *hw, 
	iwl_mvm_power_update_mode(mvm, vif);



	/* beacon filtering */

	ret = iwl_mvm_disable_beacon_filter(mvm, vif);

	if (ret)

		goto out_remove_mac;



	if (!mvm->bf_allowed_vif &&

	    vif->type == NL80211_IFTYPE_STATION && !vif->p2p &&

	    mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_BF_UPDATED){
@@ -576,10 +580,6 @@ static int iwl_mvm_mac_add_interface(struct ieee80211_hw *hw, 
		vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER;

	}



	ret = iwl_mvm_disable_beacon_filter(mvm, vif);

	if (ret)

		goto out_release;



	/*

	 * P2P_DEVICE interface does not have a channel context assigned to it,

	 * so a dedicated PHY context is allocated to it and the corresponding
@@ -590,7 +590,7 @@ static int iwl_mvm_mac_add_interface(struct ieee80211_hw *hw, 
		mvmvif->phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);

		if (!mvmvif->phy_ctxt) {

			ret = -ENOSPC;

			goto out_remove_mac;

			goto out_free_bf;

		}



		iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
@@ -614,6 +614,11 @@ static int iwl_mvm_mac_add_interface(struct ieee80211_hw *hw, 
	iwl_mvm_binding_remove_vif(mvm, vif);

 out_unref_phy:

	iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);

 out_free_bf:

	if (mvm->bf_allowed_vif == mvmvif) {

		mvm->bf_allowed_vif = NULL;

		vif->driver_flags &= ~IEEE80211_VIF_BEACON_FILTER;

	}

 out_remove_mac:

	mvmvif->phy_ctxt = NULL;

	iwl_mvm_mac_ctxt_remove(mvm, vif);

drivers/net/wireless/iwlwifi/mvm/mvm.h

+2 −0
Original line number Diff line number Diff line
@@ -421,6 +421,8 @@ struct iwl_mvm { 


	struct iwl_notif_wait_data notif_wait;



	struct mvm_statistics_rx rx_stats;



	unsigned long transport_queue_stop;

	u8 queue_to_mac80211[IWL_MAX_HW_QUEUES];

	atomic_t queue_stop_count[IWL_MAX_HW_QUEUES];