[mirror_ubuntu-zesty-kernel.git] / drivers / scsi / qla2xxx / qla_sup.c

/******************************************************************************
 *                  QLOGIC LINUX SOFTWARE
 *
 * QLogic ISP2x00 device driver for Linux 2.6.x
 * Copyright (C) 2003-2004 QLogic Corporation
 * (www.qlogic.com)
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * 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.
 *
 ******************************************************************************/

#include "qla_def.h"

#include <linux/delay.h>
#include <asm/uaccess.h>

static uint16_t qla2x00_nvram_request(scsi_qla_host_t *, uint32_t);
static void qla2x00_nv_deselect(scsi_qla_host_t *);
static void qla2x00_nv_write(scsi_qla_host_t *, uint16_t);

/*
 * NVRAM support routines
 */

/**
 * qla2x00_lock_nvram_access() - 
 * @ha: HA context
 */
void
qla2x00_lock_nvram_access(scsi_qla_host_t *ha)
{
	uint16_t data;
	device_reg_t __iomem *reg = ha->iobase;

	if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA2300(ha)) {
		data = RD_REG_WORD(&reg->nvram);
		while (data & NVR_BUSY) {
			udelay(100);
			data = RD_REG_WORD(&reg->nvram);
		}

		/* Lock resource */
		WRT_REG_WORD(&reg->u.isp2300.host_semaphore, 0x1);
		RD_REG_WORD(&reg->u.isp2300.host_semaphore);
		udelay(5);
		data = RD_REG_WORD(&reg->u.isp2300.host_semaphore);
		while ((data & BIT_0) == 0) {
			/* Lock failed */
			udelay(100);
			WRT_REG_WORD(&reg->u.isp2300.host_semaphore, 0x1);
			RD_REG_WORD(&reg->u.isp2300.host_semaphore);
			udelay(5);
			data = RD_REG_WORD(&reg->u.isp2300.host_semaphore);
		}
	}
}

/**
 * qla2x00_unlock_nvram_access() - 
 * @ha: HA context
 */
void
qla2x00_unlock_nvram_access(scsi_qla_host_t *ha)
{
	device_reg_t __iomem *reg = ha->iobase;

	if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA2300(ha)) {
		WRT_REG_WORD(&reg->u.isp2300.host_semaphore, 0);
		RD_REG_WORD(&reg->u.isp2300.host_semaphore);
	}
}

/**
 * qla2x00_release_nvram_protection() - 
 * @ha: HA context
 */
void
qla2x00_release_nvram_protection(scsi_qla_host_t *ha)
{
	device_reg_t *reg;
	uint32_t word;

	reg = ha->iobase;

	/* Release NVRAM write protection. */
	if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
		/* Write enable. */
		qla2x00_nv_write(ha, NVR_DATA_OUT);
		qla2x00_nv_write(ha, 0);
		qla2x00_nv_write(ha, 0);
		for (word = 0; word < 8; word++)
			qla2x00_nv_write(ha, NVR_DATA_OUT);

		qla2x00_nv_deselect(ha);

		/* Enable protection register. */
		qla2x00_nv_write(ha, NVR_PR_ENABLE | NVR_DATA_OUT);
		qla2x00_nv_write(ha, NVR_PR_ENABLE);
		qla2x00_nv_write(ha, NVR_PR_ENABLE);
		for (word = 0; word < 8; word++)
			qla2x00_nv_write(ha, NVR_DATA_OUT | NVR_PR_ENABLE);

		qla2x00_nv_deselect(ha);

		/* Clear protection register (ffff is cleared). */
		qla2x00_nv_write(ha, NVR_PR_ENABLE | NVR_DATA_OUT);
		qla2x00_nv_write(ha, NVR_PR_ENABLE | NVR_DATA_OUT);
		qla2x00_nv_write(ha, NVR_PR_ENABLE | NVR_DATA_OUT);
		for (word = 0; word < 8; word++)
			qla2x00_nv_write(ha, NVR_DATA_OUT | NVR_PR_ENABLE);

		qla2x00_nv_deselect(ha);

		/* Wait for NVRAM to become ready. */
		WRT_REG_WORD(&reg->nvram, NVR_SELECT);
		do {
			NVRAM_DELAY();
			word = RD_REG_WORD(&reg->nvram);
		} while ((word & NVR_DATA_IN) == 0);
	}
}

/**
 * qla2x00_get_nvram_word() - Calculates word position in NVRAM and calls the
 *	request routine to get the word from NVRAM.
 * @ha: HA context
 * @addr: Address in NVRAM to read
 *
 * Returns the word read from nvram @addr.
 */
uint16_t
qla2x00_get_nvram_word(scsi_qla_host_t *ha, uint32_t addr)
{
	uint16_t	data;
	uint32_t	nv_cmd;

	nv_cmd = addr << 16;
	nv_cmd |= NV_READ_OP;
	data = qla2x00_nvram_request(ha, nv_cmd);

	return (data);
}

/**
 * qla2x00_write_nvram_word() - Write NVRAM data.
 * @ha: HA context
 * @addr: Address in NVRAM to write
 * @data: word to program
 */
void
qla2x00_write_nvram_word(scsi_qla_host_t *ha, uint32_t addr, uint16_t data)
{
	int count;
	uint16_t word;
	uint32_t nv_cmd;
	device_reg_t __iomem *reg = ha->iobase;

	qla2x00_nv_write(ha, NVR_DATA_OUT);
	qla2x00_nv_write(ha, 0);
	qla2x00_nv_write(ha, 0);

	for (word = 0; word < 8; word++)
		qla2x00_nv_write(ha, NVR_DATA_OUT);

	qla2x00_nv_deselect(ha);

	/* Write data */
	nv_cmd = (addr << 16) | NV_WRITE_OP;
	nv_cmd |= data;
	nv_cmd <<= 5;
	for (count = 0; count < 27; count++) {
		if (nv_cmd & BIT_31)
			qla2x00_nv_write(ha, NVR_DATA_OUT);
		else
			qla2x00_nv_write(ha, 0);

		nv_cmd <<= 1;
	}

	qla2x00_nv_deselect(ha);

	/* Wait for NVRAM to become ready */
	WRT_REG_WORD(&reg->nvram, NVR_SELECT);
	do {
		NVRAM_DELAY();
		word = RD_REG_WORD(&reg->nvram);
	} while ((word & NVR_DATA_IN) == 0);

	qla2x00_nv_deselect(ha);

	/* Disable writes */
	qla2x00_nv_write(ha, NVR_DATA_OUT);
	for (count = 0; count < 10; count++)
		qla2x00_nv_write(ha, 0);

	qla2x00_nv_deselect(ha);
}

/**
 * qla2x00_nvram_request() - Sends read command to NVRAM and gets data from
 *	NVRAM.
 * @ha: HA context
 * @nv_cmd: NVRAM command
 *
 * Bit definitions for NVRAM command:
 *
 *	Bit 26     = start bit
 *	Bit 25, 24 = opcode
 *	Bit 23-16  = address
 *	Bit 15-0   = write data
 *
 * Returns the word read from nvram @addr.
 */
static uint16_t
qla2x00_nvram_request(scsi_qla_host_t *ha, uint32_t nv_cmd)
{
	uint8_t		cnt;
	device_reg_t __iomem *reg = ha->iobase;
	uint16_t	data = 0;
	uint16_t	reg_data;

	/* Send command to NVRAM. */
	nv_cmd <<= 5;
	for (cnt = 0; cnt < 11; cnt++) {
		if (nv_cmd & BIT_31)
			qla2x00_nv_write(ha, NVR_DATA_OUT);
		else
			qla2x00_nv_write(ha, 0);
		nv_cmd <<= 1;
	}

	/* Read data from NVRAM. */
	for (cnt = 0; cnt < 16; cnt++) {
		WRT_REG_WORD(&reg->nvram, NVR_SELECT | NVR_CLOCK);
		NVRAM_DELAY();
		data <<= 1;
		reg_data = RD_REG_WORD(&reg->nvram);
		if (reg_data & NVR_DATA_IN)
			data |= BIT_0;
		WRT_REG_WORD(&reg->nvram, NVR_SELECT);
		RD_REG_WORD(&reg->nvram);	/* PCI Posting. */
		NVRAM_DELAY();
	}

	/* Deselect chip. */
	WRT_REG_WORD(&reg->nvram, NVR_DESELECT);
	RD_REG_WORD(&reg->nvram);		/* PCI Posting. */
	NVRAM_DELAY();

	return (data);
}

/**
 * qla2x00_nv_write() - Clean NVRAM operations.
 * @ha: HA context
 */
static void
qla2x00_nv_deselect(scsi_qla_host_t *ha)
{
	device_reg_t __iomem *reg = ha->iobase;

	WRT_REG_WORD(&reg->nvram, NVR_DESELECT);
	RD_REG_WORD(&reg->nvram);		/* PCI Posting. */
	NVRAM_DELAY();
}

/**
 * qla2x00_nv_write() - Prepare for NVRAM read/write operation.
 * @ha: HA context
 * @data: Serial interface selector
 */
static void
qla2x00_nv_write(scsi_qla_host_t *ha, uint16_t data)
{
	device_reg_t __iomem *reg = ha->iobase;

	WRT_REG_WORD(&reg->nvram, data | NVR_SELECT | NVR_WRT_ENABLE);
	RD_REG_WORD(&reg->nvram);		/* PCI Posting. */
	NVRAM_DELAY();
	WRT_REG_WORD(&reg->nvram, data | NVR_SELECT| NVR_CLOCK |
	    NVR_WRT_ENABLE);
	RD_REG_WORD(&reg->nvram);		/* PCI Posting. */
	NVRAM_DELAY();
	WRT_REG_WORD(&reg->nvram, data | NVR_SELECT | NVR_WRT_ENABLE);
	RD_REG_WORD(&reg->nvram);		/* PCI Posting. */
	NVRAM_DELAY();
}
Commit	Line	Data
1da177e4 LT	1	/******************************************************************************
	2	* QLOGIC LINUX SOFTWARE
	3	*
	4	* QLogic ISP2x00 device driver for Linux 2.6.x
	5	* Copyright (C) 2003-2004 QLogic Corporation
	6	* (www.qlogic.com)
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2, or (at your option) any
	11	* later version.
	12	*
	13	* This program is distributed in the hope that it will be useful, but
	14	* WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* General Public License for more details.
	17	*
	18	******************************************************************************/
	19
	20	#include "qla_def.h"
	21
	22	#include <linux/delay.h>
	23	#include <asm/uaccess.h>
	24
	25	static uint16_t qla2x00_nvram_request(scsi_qla_host_t *, uint32_t);
	26	static void qla2x00_nv_deselect(scsi_qla_host_t *);
	27	static void qla2x00_nv_write(scsi_qla_host_t *, uint16_t);
	28
	29	/*
	30	* NVRAM support routines
	31	*/
	32
	33	/**
	34	* qla2x00_lock_nvram_access() -
	35	* @ha: HA context
	36	*/
	37	void
	38	qla2x00_lock_nvram_access(scsi_qla_host_t *ha)
	39	{
	40	uint16_t data;
	41	device_reg_t __iomem *reg = ha->iobase;
	42
	43	if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA2300(ha)) {
	44	data = RD_REG_WORD(&reg->nvram);
	45	while (data & NVR_BUSY) {
	46	udelay(100);
	47	data = RD_REG_WORD(&reg->nvram);
	48	}
	49
	50	/* Lock resource */
	51	WRT_REG_WORD(&reg->u.isp2300.host_semaphore, 0x1);
	52	RD_REG_WORD(&reg->u.isp2300.host_semaphore);
	53	udelay(5);
	54	data = RD_REG_WORD(&reg->u.isp2300.host_semaphore);
	55	while ((data & BIT_0) == 0) {
	56	/* Lock failed */
	57	udelay(100);
	58	WRT_REG_WORD(&reg->u.isp2300.host_semaphore, 0x1);
	59	RD_REG_WORD(&reg->u.isp2300.host_semaphore);
	60	udelay(5);
	61	data = RD_REG_WORD(&reg->u.isp2300.host_semaphore);
	62	}
	63	}
	64	}
65
66	/**
67	* qla2x00_unlock_nvram_access() -
68	* @ha: HA context
69	*/
70	void
71	qla2x00_unlock_nvram_access(scsi_qla_host_t *ha)
72	{
73	device_reg_t __iomem *reg = ha->iobase;
74
75	if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA2300(ha)) {
76	WRT_REG_WORD(&reg->u.isp2300.host_semaphore, 0);
77	RD_REG_WORD(&reg->u.isp2300.host_semaphore);
78	}
79	}
80
81	/**
82	* qla2x00_release_nvram_protection() -
83	* @ha: HA context
84	*/
85	void
86	qla2x00_release_nvram_protection(scsi_qla_host_t *ha)
87	{
88	device_reg_t *reg;
89	uint32_t word;
90
91	reg = ha->iobase;
92
93	/* Release NVRAM write protection. */
94	if (IS_QLA2322(ha) \|\| IS_QLA6322(ha)) {
95	/* Write enable. */
96	qla2x00_nv_write(ha, NVR_DATA_OUT);
97	qla2x00_nv_write(ha, 0);
98	qla2x00_nv_write(ha, 0);
99	for (word = 0; word < 8; word++)
100	qla2x00_nv_write(ha, NVR_DATA_OUT);
101
102	qla2x00_nv_deselect(ha);
103
104	/* Enable protection register. */
105	qla2x00_nv_write(ha, NVR_PR_ENABLE \| NVR_DATA_OUT);
106	qla2x00_nv_write(ha, NVR_PR_ENABLE);
107	qla2x00_nv_write(ha, NVR_PR_ENABLE);
108	for (word = 0; word < 8; word++)
109	qla2x00_nv_write(ha, NVR_DATA_OUT \| NVR_PR_ENABLE);
110
111	qla2x00_nv_deselect(ha);
112
113	/* Clear protection register (ffff is cleared). */
114	qla2x00_nv_write(ha, NVR_PR_ENABLE \| NVR_DATA_OUT);
115	qla2x00_nv_write(ha, NVR_PR_ENABLE \| NVR_DATA_OUT);
116	qla2x00_nv_write(ha, NVR_PR_ENABLE \| NVR_DATA_OUT);
117	for (word = 0; word < 8; word++)
118	qla2x00_nv_write(ha, NVR_DATA_OUT \| NVR_PR_ENABLE);
119
120	qla2x00_nv_deselect(ha);
121
122	/* Wait for NVRAM to become ready. */
123	WRT_REG_WORD(&reg->nvram, NVR_SELECT);
124	do {
125	NVRAM_DELAY();
126	word = RD_REG_WORD(&reg->nvram);
127	} while ((word & NVR_DATA_IN) == 0);
128	}
129	}
130
131	/**
132	* qla2x00_get_nvram_word() - Calculates word position in NVRAM and calls the
133	* request routine to get the word from NVRAM.
134	* @ha: HA context
135	* @addr: Address in NVRAM to read
136	*
137	* Returns the word read from nvram @addr.
138	*/
139	uint16_t
140	qla2x00_get_nvram_word(scsi_qla_host_t *ha, uint32_t addr)
141	{
142	uint16_t data;
143	uint32_t nv_cmd;
144
145	nv_cmd = addr << 16;
146	nv_cmd \|= NV_READ_OP;
147	data = qla2x00_nvram_request(ha, nv_cmd);
148
149	return (data);
150	}
151
152	/**
153	* qla2x00_write_nvram_word() - Write NVRAM data.
154	* @ha: HA context
155	* @addr: Address in NVRAM to write
156	* @data: word to program
157	*/
158	void
159	qla2x00_write_nvram_word(scsi_qla_host_t *ha, uint32_t addr, uint16_t data)
160	{
161	int count;
162	uint16_t word;
163	uint32_t nv_cmd;
164	device_reg_t __iomem *reg = ha->iobase;
165
166	qla2x00_nv_write(ha, NVR_DATA_OUT);
167	qla2x00_nv_write(ha, 0);
168	qla2x00_nv_write(ha, 0);
169
170	for (word = 0; word < 8; word++)
171	qla2x00_nv_write(ha, NVR_DATA_OUT);
172
173	qla2x00_nv_deselect(ha);
174
175	/* Write data */
176	nv_cmd = (addr << 16) \| NV_WRITE_OP;
177	nv_cmd \|= data;
178	nv_cmd <<= 5;
179	for (count = 0; count < 27; count++) {
180	if (nv_cmd & BIT_31)
181	qla2x00_nv_write(ha, NVR_DATA_OUT);
182	else
183	qla2x00_nv_write(ha, 0);
184
185	nv_cmd <<= 1;
186	}
187
188	qla2x00_nv_deselect(ha);
189
190	/* Wait for NVRAM to become ready */
191	WRT_REG_WORD(&reg->nvram, NVR_SELECT);
192	do {
193	NVRAM_DELAY();
194	word = RD_REG_WORD(&reg->nvram);
195	} while ((word & NVR_DATA_IN) == 0);
196
197	qla2x00_nv_deselect(ha);
198
199	/* Disable writes */
200	qla2x00_nv_write(ha, NVR_DATA_OUT);
201	for (count = 0; count < 10; count++)
202	qla2x00_nv_write(ha, 0);
203
204	qla2x00_nv_deselect(ha);
205	}
206
207	/**
208	* qla2x00_nvram_request() - Sends read command to NVRAM and gets data from
209	* NVRAM.
210	* @ha: HA context
211	* @nv_cmd: NVRAM command
212	*
213	* Bit definitions for NVRAM command:
214	*
215	* Bit 26 = start bit
216	* Bit 25, 24 = opcode
217	* Bit 23-16 = address
218	* Bit 15-0 = write data
219	*
220	* Returns the word read from nvram @addr.
221	*/
222	static uint16_t
223	qla2x00_nvram_request(scsi_qla_host_t *ha, uint32_t nv_cmd)
224	{
225	uint8_t cnt;
226	device_reg_t __iomem *reg = ha->iobase;
227	uint16_t data = 0;
228	uint16_t reg_data;
229
230	/* Send command to NVRAM. */
231	nv_cmd <<= 5;
232	for (cnt = 0; cnt < 11; cnt++) {
233	if (nv_cmd & BIT_31)
234	qla2x00_nv_write(ha, NVR_DATA_OUT);
235	else
236	qla2x00_nv_write(ha, 0);
237	nv_cmd <<= 1;
238	}
239
240	/* Read data from NVRAM. */
241	for (cnt = 0; cnt < 16; cnt++) {
242	WRT_REG_WORD(&reg->nvram, NVR_SELECT \| NVR_CLOCK);
243	NVRAM_DELAY();
244	data <<= 1;
245	reg_data = RD_REG_WORD(&reg->nvram);
246	if (reg_data & NVR_DATA_IN)
247	data \|= BIT_0;
248	WRT_REG_WORD(&reg->nvram, NVR_SELECT);
249	RD_REG_WORD(&reg->nvram); /* PCI Posting. */
250	NVRAM_DELAY();
251	}
252
253	/* Deselect chip. */
254	WRT_REG_WORD(&reg->nvram, NVR_DESELECT);
255	RD_REG_WORD(&reg->nvram); /* PCI Posting. */
256	NVRAM_DELAY();
257
258	return (data);
259	}
260
261	/**
262	* qla2x00_nv_write() - Clean NVRAM operations.
263	* @ha: HA context
264	*/
265	static void
266	qla2x00_nv_deselect(scsi_qla_host_t *ha)
267	{
268	device_reg_t __iomem *reg = ha->iobase;
269
270	WRT_REG_WORD(&reg->nvram, NVR_DESELECT);
271	RD_REG_WORD(&reg->nvram); /* PCI Posting. */
272	NVRAM_DELAY();
273	}
274
275	/**
276	* qla2x00_nv_write() - Prepare for NVRAM read/write operation.
277	* @ha: HA context
278	* @data: Serial interface selector
279	*/
280	static void
281	qla2x00_nv_write(scsi_qla_host_t *ha, uint16_t data)
282	{
283	device_reg_t __iomem *reg = ha->iobase;
284
285	WRT_REG_WORD(&reg->nvram, data \| NVR_SELECT \| NVR_WRT_ENABLE);
286	RD_REG_WORD(&reg->nvram); /* PCI Posting. */
287	NVRAM_DELAY();
288	WRT_REG_WORD(&reg->nvram, data \| NVR_SELECT\| NVR_CLOCK \|
289	NVR_WRT_ENABLE);
290	RD_REG_WORD(&reg->nvram); /* PCI Posting. */
291	NVRAM_DELAY();
292	WRT_REG_WORD(&reg->nvram, data \| NVR_SELECT \| NVR_WRT_ENABLE);
293	RD_REG_WORD(&reg->nvram); /* PCI Posting. */
294	NVRAM_DELAY();
295	}
296