[deliverable/linux.git] / drivers / net / wireless / iwlwifi / iwl-io.c

/******************************************************************************
 *
 * Copyright(c) 2003 - 2013 Intel Corporation. All rights reserved.
 *
 * Portions of this file are derived from the ipw3945 project.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * Contact Information:
 *  Intel Linux Wireless <ilw@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/export.h>

#include "iwl-drv.h"
#include "iwl-io.h"
#include "iwl-csr.h"
#include "iwl-debug.h"
#include "iwl-fh.h"

#define IWL_POLL_INTERVAL 10	/* microseconds */

int iwl_poll_bit(struct iwl_trans *trans, u32 addr,
		 u32 bits, u32 mask, int timeout)
{
	int t = 0;

	do {
		if ((iwl_read32(trans, addr) & mask) == (bits & mask))
			return t;
		udelay(IWL_POLL_INTERVAL);
		t += IWL_POLL_INTERVAL;
	} while (t < timeout);

	return -ETIMEDOUT;
}
IWL_EXPORT_SYMBOL(iwl_poll_bit);

u32 iwl_read_direct32(struct iwl_trans *trans, u32 reg)
{
	u32 value = 0x5a5a5a5a;
	unsigned long flags;
	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
		value = iwl_read32(trans, reg);
		iwl_trans_release_nic_access(trans, &flags);
	}

	return value;
}
IWL_EXPORT_SYMBOL(iwl_read_direct32);

void iwl_write_direct32(struct iwl_trans *trans, u32 reg, u32 value)
{
	unsigned long flags;

	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
		iwl_write32(trans, reg, value);
		iwl_trans_release_nic_access(trans, &flags);
	}
}
IWL_EXPORT_SYMBOL(iwl_write_direct32);

int iwl_poll_direct_bit(struct iwl_trans *trans, u32 addr, u32 mask,
			int timeout)
{
	int t = 0;

	do {
		if ((iwl_read_direct32(trans, addr) & mask) == mask)
			return t;
		udelay(IWL_POLL_INTERVAL);
		t += IWL_POLL_INTERVAL;
	} while (t < timeout);

	return -ETIMEDOUT;
}
IWL_EXPORT_SYMBOL(iwl_poll_direct_bit);

static inline u32 __iwl_read_prph(struct iwl_trans *trans, u32 ofs)
{
	u32 val = iwl_trans_read_prph(trans, ofs);
	trace_iwlwifi_dev_ioread_prph32(trans->dev, ofs, val);
	return val;
}

static inline void __iwl_write_prph(struct iwl_trans *trans, u32 ofs, u32 val)
{
	trace_iwlwifi_dev_iowrite_prph32(trans->dev, ofs, val);
	iwl_trans_write_prph(trans, ofs, val);
}

u32 iwl_read_prph(struct iwl_trans *trans, u32 ofs)
{
	unsigned long flags;
	u32 val = 0x5a5a5a5a;

	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
		val = __iwl_read_prph(trans, ofs);
		iwl_trans_release_nic_access(trans, &flags);
	}
	return val;
}
IWL_EXPORT_SYMBOL(iwl_read_prph);

void iwl_write_prph(struct iwl_trans *trans, u32 ofs, u32 val)
{
	unsigned long flags;

	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
		__iwl_write_prph(trans, ofs, val);
		iwl_trans_release_nic_access(trans, &flags);
	}
}
IWL_EXPORT_SYMBOL(iwl_write_prph);

void iwl_set_bits_prph(struct iwl_trans *trans, u32 ofs, u32 mask)
{
	unsigned long flags;

	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
		__iwl_write_prph(trans, ofs,
				 __iwl_read_prph(trans, ofs) | mask);
		iwl_trans_release_nic_access(trans, &flags);
	}
}
IWL_EXPORT_SYMBOL(iwl_set_bits_prph);

void iwl_set_bits_mask_prph(struct iwl_trans *trans, u32 ofs,
			    u32 bits, u32 mask)
{
	unsigned long flags;

	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
		__iwl_write_prph(trans, ofs,
				 (__iwl_read_prph(trans, ofs) & mask) | bits);
		iwl_trans_release_nic_access(trans, &flags);
	}
}
IWL_EXPORT_SYMBOL(iwl_set_bits_mask_prph);

void iwl_clear_bits_prph(struct iwl_trans *trans, u32 ofs, u32 mask)
{
	unsigned long flags;
	u32 val;

	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
		val = __iwl_read_prph(trans, ofs);
		__iwl_write_prph(trans, ofs, (val & ~mask));
		iwl_trans_release_nic_access(trans, &flags);
	}
}
IWL_EXPORT_SYMBOL(iwl_clear_bits_prph);

static const char *get_fh_string(int cmd)
{
#define IWL_CMD(x) case x: return #x
	switch (cmd) {
	IWL_CMD(FH_RSCSR_CHNL0_STTS_WPTR_REG);
	IWL_CMD(FH_RSCSR_CHNL0_RBDCB_BASE_REG);
	IWL_CMD(FH_RSCSR_CHNL0_WPTR);
	IWL_CMD(FH_MEM_RCSR_CHNL0_CONFIG_REG);
	IWL_CMD(FH_MEM_RSSR_SHARED_CTRL_REG);
	IWL_CMD(FH_MEM_RSSR_RX_STATUS_REG);
	IWL_CMD(FH_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV);
	IWL_CMD(FH_TSSR_TX_STATUS_REG);
	IWL_CMD(FH_TSSR_TX_ERROR_REG);
	default:
		return "UNKNOWN";
	}
#undef IWL_CMD
}

int iwl_dump_fh(struct iwl_trans *trans, char **buf)
{
	int i;
	static const u32 fh_tbl[] = {
		FH_RSCSR_CHNL0_STTS_WPTR_REG,
		FH_RSCSR_CHNL0_RBDCB_BASE_REG,
		FH_RSCSR_CHNL0_WPTR,
		FH_MEM_RCSR_CHNL0_CONFIG_REG,
		FH_MEM_RSSR_SHARED_CTRL_REG,
		FH_MEM_RSSR_RX_STATUS_REG,
		FH_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV,
		FH_TSSR_TX_STATUS_REG,
		FH_TSSR_TX_ERROR_REG
	};

#ifdef CONFIG_IWLWIFI_DEBUGFS
	if (buf) {
		int pos = 0;
		size_t bufsz = ARRAY_SIZE(fh_tbl) * 48 + 40;

		*buf = kmalloc(bufsz, GFP_KERNEL);
		if (!*buf)
			return -ENOMEM;

		pos += scnprintf(*buf + pos, bufsz - pos,
				"FH register values:\n");

		for (i = 0; i < ARRAY_SIZE(fh_tbl); i++)
			pos += scnprintf(*buf + pos, bufsz - pos,
				"  %34s: 0X%08x\n",
				get_fh_string(fh_tbl[i]),
				iwl_read_direct32(trans, fh_tbl[i]));

		return pos;
	}
#endif

	IWL_ERR(trans, "FH register values:\n");
	for (i = 0; i <  ARRAY_SIZE(fh_tbl); i++)
		IWL_ERR(trans, "  %34s: 0X%08x\n",
			get_fh_string(fh_tbl[i]),
			iwl_read_direct32(trans, fh_tbl[i]));

	return 0;
}
Commit	Line	Data
	1	/******************************************************************************
	2	*
	3	* Copyright(c) 2003 - 2013 Intel Corporation. All rights reserved.
	4	*
	5	* Portions of this file are derived from the ipw3945 project.
	6	*
	7	* This program is free software; you can redistribute it and/or modify it
	8	* under the terms of version 2 of the GNU General Public License as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	14	* more details.
	15	*
	16	* You should have received a copy of the GNU General Public License along with
	17	* this program; if not, write to the Free Software Foundation, Inc.,
	18	* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
	19	*
	20	* The full GNU General Public License is included in this distribution in the
	21	* file called LICENSE.
	22	*
	23	* Contact Information:
	24	* Intel Linux Wireless <ilw@linux.intel.com>
	25	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	26	*
	27	*****************************************************************************/
	28	#include <linux/delay.h>
	29	#include <linux/device.h>
	30	#include <linux/export.h>
	31
	32	#include "iwl-drv.h"
	33	#include "iwl-io.h"
	34	#include "iwl-csr.h"
	35	#include "iwl-debug.h"
	36	#include "iwl-fh.h"
	37
	38	#define IWL_POLL_INTERVAL 10 /* microseconds */
	39
	40	int iwl_poll_bit(struct iwl_trans *trans, u32 addr,
	41	u32 bits, u32 mask, int timeout)
	42	{
	43	int t = 0;
	44
	45	do {
	46	if ((iwl_read32(trans, addr) & mask) == (bits & mask))
	47	return t;
	48	udelay(IWL_POLL_INTERVAL);
	49	t += IWL_POLL_INTERVAL;
	50	} while (t < timeout);
	51
	52	return -ETIMEDOUT;
	53	}
	54	IWL_EXPORT_SYMBOL(iwl_poll_bit);
	55
	56	u32 iwl_read_direct32(struct iwl_trans *trans, u32 reg)
	57	{
	58	u32 value = 0x5a5a5a5a;
	59	unsigned long flags;
	60	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
	61	value = iwl_read32(trans, reg);
	62	iwl_trans_release_nic_access(trans, &flags);
	63	}
	64
	65	return value;
	66	}
	67	IWL_EXPORT_SYMBOL(iwl_read_direct32);
	68
	69	void iwl_write_direct32(struct iwl_trans *trans, u32 reg, u32 value)
	70	{
	71	unsigned long flags;
	72
	73	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
	74	iwl_write32(trans, reg, value);
	75	iwl_trans_release_nic_access(trans, &flags);
	76	}
	77	}
	78	IWL_EXPORT_SYMBOL(iwl_write_direct32);
	79
	80	int iwl_poll_direct_bit(struct iwl_trans *trans, u32 addr, u32 mask,
	81	int timeout)
	82	{
	83	int t = 0;
	84
	85	do {
	86	if ((iwl_read_direct32(trans, addr) & mask) == mask)
	87	return t;
	88	udelay(IWL_POLL_INTERVAL);
	89	t += IWL_POLL_INTERVAL;
	90	} while (t < timeout);
	91
	92	return -ETIMEDOUT;
	93	}
	94	IWL_EXPORT_SYMBOL(iwl_poll_direct_bit);
	95
	96	static inline u32 __iwl_read_prph(struct iwl_trans *trans, u32 ofs)
	97	{
	98	u32 val = iwl_trans_read_prph(trans, ofs);
	99	trace_iwlwifi_dev_ioread_prph32(trans->dev, ofs, val);
	100	return val;
	101	}
	102
	103	static inline void __iwl_write_prph(struct iwl_trans *trans, u32 ofs, u32 val)
	104	{
	105	trace_iwlwifi_dev_iowrite_prph32(trans->dev, ofs, val);
	106	iwl_trans_write_prph(trans, ofs, val);
	107	}
	108
	109	u32 iwl_read_prph(struct iwl_trans *trans, u32 ofs)
	110	{
	111	unsigned long flags;
	112	u32 val = 0x5a5a5a5a;
	113
	114	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
	115	val = __iwl_read_prph(trans, ofs);
	116	iwl_trans_release_nic_access(trans, &flags);
	117	}
	118	return val;
	119	}
	120	IWL_EXPORT_SYMBOL(iwl_read_prph);
	121
	122	void iwl_write_prph(struct iwl_trans *trans, u32 ofs, u32 val)
	123	{
	124	unsigned long flags;
	125
	126	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
	127	__iwl_write_prph(trans, ofs, val);
	128	iwl_trans_release_nic_access(trans, &flags);
	129	}
	130	}
	131	IWL_EXPORT_SYMBOL(iwl_write_prph);
	132
	133	void iwl_set_bits_prph(struct iwl_trans *trans, u32 ofs, u32 mask)
	134	{
	135	unsigned long flags;
	136
	137	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
	138	__iwl_write_prph(trans, ofs,
	139	__iwl_read_prph(trans, ofs) \| mask);
	140	iwl_trans_release_nic_access(trans, &flags);
	141	}
	142	}
	143	IWL_EXPORT_SYMBOL(iwl_set_bits_prph);
	144
	145	void iwl_set_bits_mask_prph(struct iwl_trans *trans, u32 ofs,
	146	u32 bits, u32 mask)
	147	{
	148	unsigned long flags;
	149
	150	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
	151	__iwl_write_prph(trans, ofs,
	152	(__iwl_read_prph(trans, ofs) & mask) \| bits);
	153	iwl_trans_release_nic_access(trans, &flags);
	154	}
	155	}
	156	IWL_EXPORT_SYMBOL(iwl_set_bits_mask_prph);
	157
	158	void iwl_clear_bits_prph(struct iwl_trans *trans, u32 ofs, u32 mask)
	159	{
	160	unsigned long flags;
	161	u32 val;
	162
	163	if (iwl_trans_grab_nic_access(trans, false, &flags)) {
	164	val = __iwl_read_prph(trans, ofs);
	165	__iwl_write_prph(trans, ofs, (val & ~mask));
	166	iwl_trans_release_nic_access(trans, &flags);
	167	}
	168	}
	169	IWL_EXPORT_SYMBOL(iwl_clear_bits_prph);
	170
	171	static const char *get_fh_string(int cmd)
	172	{
	173	#define IWL_CMD(x) case x: return #x
	174	switch (cmd) {
	175	IWL_CMD(FH_RSCSR_CHNL0_STTS_WPTR_REG);
	176	IWL_CMD(FH_RSCSR_CHNL0_RBDCB_BASE_REG);
	177	IWL_CMD(FH_RSCSR_CHNL0_WPTR);
	178	IWL_CMD(FH_MEM_RCSR_CHNL0_CONFIG_REG);
	179	IWL_CMD(FH_MEM_RSSR_SHARED_CTRL_REG);
	180	IWL_CMD(FH_MEM_RSSR_RX_STATUS_REG);
	181	IWL_CMD(FH_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV);
	182	IWL_CMD(FH_TSSR_TX_STATUS_REG);
	183	IWL_CMD(FH_TSSR_TX_ERROR_REG);
	184	default:
	185	return "UNKNOWN";
	186	}
	187	#undef IWL_CMD
	188	}
	189
	190	int iwl_dump_fh(struct iwl_trans trans, char *buf)
	191	{
	192	int i;
	193	static const u32 fh_tbl[] = {
	194	FH_RSCSR_CHNL0_STTS_WPTR_REG,
	195	FH_RSCSR_CHNL0_RBDCB_BASE_REG,
	196	FH_RSCSR_CHNL0_WPTR,
	197	FH_MEM_RCSR_CHNL0_CONFIG_REG,
	198	FH_MEM_RSSR_SHARED_CTRL_REG,
	199	FH_MEM_RSSR_RX_STATUS_REG,
	200	FH_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV,
	201	FH_TSSR_TX_STATUS_REG,
	202	FH_TSSR_TX_ERROR_REG
	203	};
	204
	205	#ifdef CONFIG_IWLWIFI_DEBUGFS
	206	if (buf) {
	207	int pos = 0;
	208	size_t bufsz = ARRAY_SIZE(fh_tbl) * 48 + 40;
	209
	210	*buf = kmalloc(bufsz, GFP_KERNEL);
	211	if (!*buf)
	212	return -ENOMEM;
	213
	214	pos += scnprintf(*buf + pos, bufsz - pos,
	215	"FH register values:\n");
	216
	217	for (i = 0; i < ARRAY_SIZE(fh_tbl); i++)
	218	pos += scnprintf(*buf + pos, bufsz - pos,
	219	" %34s: 0X%08x\n",
	220	get_fh_string(fh_tbl[i]),
	221	iwl_read_direct32(trans, fh_tbl[i]));
	222
	223	return pos;
	224	}
	225	#endif
	226
	227	IWL_ERR(trans, "FH register values:\n");
	228	for (i = 0; i < ARRAY_SIZE(fh_tbl); i++)
	229	IWL_ERR(trans, " %34s: 0X%08x\n",
	230	get_fh_string(fh_tbl[i]),
	231	iwl_read_direct32(trans, fh_tbl[i]));
	232
	233	return 0;
	234	}