1 /*****************************************************************************
2  *
3  *     Author: Xilinx, Inc.
4  *
5  *     This program is free software; you can redistribute it and/or modify it
6  *     under the terms of the GNU General Public License as published by the
7  *     Free Software Foundation; either version 2 of the License, or (at your
8  *     option) any later version.
9  *
10  *     XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS"
11  *     AS A COURTESY TO YOU, SOLELY FOR USE IN DEVELOPING PROGRAMS AND
12  *     SOLUTIONS FOR XILINX DEVICES.  BY PROVIDING THIS DESIGN, CODE,
13  *     OR INFORMATION AS ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE,
14  *     APPLICATION OR STANDARD, XILINX IS MAKING NO REPRESENTATION
15  *     THAT THIS IMPLEMENTATION IS FREE FROM ANY CLAIMS OF INFRINGEMENT,
16  *     AND YOU ARE RESPONSIBLE FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE
17  *     FOR YOUR IMPLEMENTATION.  XILINX EXPRESSLY DISCLAIMS ANY
18  *     WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE
19  *     IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR
20  *     REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF
21  *     INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
22  *     FOR A PARTICULAR PURPOSE.
23  *
24  *     (c) Copyright 2007-2008 Xilinx Inc.
25  *     All rights reserved.
26  *
27  *     You should have received a copy of the GNU General Public License along
28  *     with this program; if not, write to the Free Software Foundation, Inc.,
29  *     675 Mass Ave, Cambridge, MA 02139, USA.
30  *
31  *****************************************************************************/
32 
33 #include "fifo_icap.h"
34 
35 /* Register offsets for the XHwIcap device. */
36 #define XHI_GIER_OFFSET	0x1C  /* Device Global Interrupt Enable Reg */
37 #define XHI_IPISR_OFFSET 0x20  /* Interrupt Status Register */
38 #define XHI_IPIER_OFFSET 0x28  /* Interrupt Enable Register */
39 #define XHI_WF_OFFSET 0x100 /* Write FIFO */
40 #define XHI_RF_OFFSET 0x104 /* Read FIFO */
41 #define XHI_SZ_OFFSET 0x108 /* Size Register */
42 #define XHI_CR_OFFSET 0x10C /* Control Register */
43 #define XHI_SR_OFFSET 0x110 /* Status Register */
44 #define XHI_WFV_OFFSET 0x114 /* Write FIFO Vacancy Register */
45 #define XHI_RFO_OFFSET 0x118 /* Read FIFO Occupancy Register */
46 
47 /* Device Global Interrupt Enable Register (GIER) bit definitions */
48 
49 #define XHI_GIER_GIE_MASK 0x80000000 /* Global Interrupt enable Mask */
50 
51 /**
52  * HwIcap Device Interrupt Status/Enable Registers
53  *
54  * Interrupt Status Register (IPISR) : This register holds the
55  * interrupt status flags for the device. These bits are toggle on
56  * write.
57  *
58  * Interrupt Enable Register (IPIER) : This register is used to enable
59  * interrupt sources for the device.
60  * Writing a '1' to a bit enables the corresponding interrupt.
61  * Writing a '0' to a bit disables the corresponding interrupt.
62  *
63  * IPISR/IPIER registers have the same bit definitions and are only defined
64  * once.
65  */
66 #define XHI_IPIXR_RFULL_MASK 0x00000008 /* Read FIFO Full */
67 #define XHI_IPIXR_WEMPTY_MASK 0x00000004 /* Write FIFO Empty */
68 #define XHI_IPIXR_RDP_MASK 0x00000002 /* Read FIFO half full */
69 #define XHI_IPIXR_WRP_MASK 0x00000001 /* Write FIFO half full */
70 #define XHI_IPIXR_ALL_MASK 0x0000000F /* Mask of all interrupts */
71 
72 /* Control Register (CR) */
73 #define XHI_CR_SW_RESET_MASK 0x00000008 /* SW Reset Mask */
74 #define XHI_CR_FIFO_CLR_MASK 0x00000004 /* FIFO Clear Mask */
75 #define XHI_CR_READ_MASK 0x00000002 /* Read from ICAP to FIFO */
76 #define XHI_CR_WRITE_MASK 0x00000001 /* Write from FIFO to ICAP */
77 
78 
79 #define XHI_WFO_MAX_VACANCY 1024 /* Max Write FIFO Vacancy, in words */
80 #define XHI_RFO_MAX_OCCUPANCY 256 /* Max Read FIFO Occupancy, in words */
81 /* The maximum amount we can request from fifo_icap_get_configuration
82    at once, in bytes. */
83 #define XHI_MAX_READ_TRANSACTION_WORDS 0xFFF
84 
85 
86 /**
87  * fifo_icap_fifo_write - Write data to the write FIFO.
88  * @drvdata: a pointer to the drvdata.
89  * @data: the 32-bit value to be written to the FIFO.
90  *
91  * This function will silently fail if the fifo is full.
92  **/
93 static inline void fifo_icap_fifo_write(struct hwicap_drvdata *drvdata,
94 		u32 data)
95 {
96 	dev_dbg(drvdata->dev, "fifo_write: %x\n", data);
97 	out_be32(drvdata->base_address + XHI_WF_OFFSET, data);
98 }
99 
100 /**
101  * fifo_icap_fifo_read - Read data from the Read FIFO.
102  * @drvdata: a pointer to the drvdata.
103  *
104  * This function will silently fail if the fifo is empty.
105  **/
106 static inline u32 fifo_icap_fifo_read(struct hwicap_drvdata *drvdata)
107 {
108 	u32 data = in_be32(drvdata->base_address + XHI_RF_OFFSET);
109 	dev_dbg(drvdata->dev, "fifo_read: %x\n", data);
110 	return data;
111 }
112 
113 /**
114  * fifo_icap_set_read_size - Set the size register.
115  * @drvdata: a pointer to the drvdata.
116  * @data: the size of the following read transaction, in words.
117  **/
118 static inline void fifo_icap_set_read_size(struct hwicap_drvdata *drvdata,
119 		u32 data)
120 {
121 	out_be32(drvdata->base_address + XHI_SZ_OFFSET, data);
122 }
123 
124 /**
125  * fifo_icap_start_config - Initiate a configuration (write) to the device.
126  * @drvdata: a pointer to the drvdata.
127  **/
128 static inline void fifo_icap_start_config(struct hwicap_drvdata *drvdata)
129 {
130 	out_be32(drvdata->base_address + XHI_CR_OFFSET, XHI_CR_WRITE_MASK);
131 	dev_dbg(drvdata->dev, "configuration started\n");
132 }
133 
134 /**
135  * fifo_icap_start_readback - Initiate a readback from the device.
136  * @drvdata: a pointer to the drvdata.
137  **/
138 static inline void fifo_icap_start_readback(struct hwicap_drvdata *drvdata)
139 {
140 	out_be32(drvdata->base_address + XHI_CR_OFFSET, XHI_CR_READ_MASK);
141 	dev_dbg(drvdata->dev, "readback started\n");
142 }
143 
144 /**
145  * fifo_icap_get_status - Get the contents of the status register.
146  * @drvdata: a pointer to the drvdata.
147  *
148  * The status register contains the ICAP status and the done bit.
149  *
150  * D8 - cfgerr
151  * D7 - dalign
152  * D6 - rip
153  * D5 - in_abort_l
154  * D4 - Always 1
155  * D3 - Always 1
156  * D2 - Always 1
157  * D1 - Always 1
158  * D0 - Done bit
159  **/
160 u32 fifo_icap_get_status(struct hwicap_drvdata *drvdata)
161 {
162 	u32 status = in_be32(drvdata->base_address + XHI_SR_OFFSET);
163 	dev_dbg(drvdata->dev, "Getting status = %x\n", status);
164 	return status;
165 }
166 
167 /**
168  * fifo_icap_busy - Return true if the ICAP is still processing a transaction.
169  * @drvdata: a pointer to the drvdata.
170  **/
171 static inline u32 fifo_icap_busy(struct hwicap_drvdata *drvdata)
172 {
173 	u32 status = in_be32(drvdata->base_address + XHI_SR_OFFSET);
174 	return (status & XHI_SR_DONE_MASK) ? 0 : 1;
175 }
176 
177 /**
178  * fifo_icap_write_fifo_vacancy - Query the write fifo available space.
179  * @drvdata: a pointer to the drvdata.
180  *
181  * Return the number of words that can be safely pushed into the write fifo.
182  **/
183 static inline u32 fifo_icap_write_fifo_vacancy(
184 		struct hwicap_drvdata *drvdata)
185 {
186 	return in_be32(drvdata->base_address + XHI_WFV_OFFSET);
187 }
188 
189 /**
190  * fifo_icap_read_fifo_occupancy - Query the read fifo available data.
191  * @drvdata: a pointer to the drvdata.
192  *
193  * Return the number of words that can be safely read from the read fifo.
194  **/
195 static inline u32 fifo_icap_read_fifo_occupancy(
196 		struct hwicap_drvdata *drvdata)
197 {
198 	return in_be32(drvdata->base_address + XHI_RFO_OFFSET);
199 }
200 
201 /**
202  * fifo_icap_set_configuration - Send configuration data to the ICAP.
203  * @drvdata: a pointer to the drvdata.
204  * @frame_buffer: a pointer to the data to be written to the
205  *		ICAP device.
206  * @num_words: the number of words (32 bit) to write to the ICAP
207  *		device.
208 
209  * This function writes the given user data to the Write FIFO in
210  * polled mode and starts the transfer of the data to
211  * the ICAP device.
212  **/
213 int fifo_icap_set_configuration(struct hwicap_drvdata *drvdata,
214 		u32 *frame_buffer, u32 num_words)
215 {
216 
217 	u32 write_fifo_vacancy = 0;
218 	u32 retries = 0;
219 	u32 remaining_words;
220 
221 	dev_dbg(drvdata->dev, "fifo_set_configuration\n");
222 
223 	/*
224 	 * Check if the ICAP device is Busy with the last Read/Write
225 	 */
226 	if (fifo_icap_busy(drvdata))
227 		return -EBUSY;
228 
229 	/*
230 	 * Set up the buffer pointer and the words to be transferred.
231 	 */
232 	remaining_words = num_words;
233 
234 	while (remaining_words > 0) {
235 		/*
236 		 * Wait until we have some data in the fifo.
237 		 */
238 		while (write_fifo_vacancy == 0) {
239 			write_fifo_vacancy =
240 				fifo_icap_write_fifo_vacancy(drvdata);
241 			retries++;
242 			if (retries > XHI_MAX_RETRIES)
243 				return -EIO;
244 		}
245 
246 		/*
247 		 * Write data into the Write FIFO.
248 		 */
249 		while ((write_fifo_vacancy != 0) &&
250 				(remaining_words > 0)) {
251 			fifo_icap_fifo_write(drvdata, *frame_buffer);
252 
253 			remaining_words--;
254 			write_fifo_vacancy--;
255 			frame_buffer++;
256 		}
257 		/* Start pushing whatever is in the FIFO into the ICAP. */
258 		fifo_icap_start_config(drvdata);
259 	}
260 
261 	/* Wait until the write has finished. */
262 	while (fifo_icap_busy(drvdata)) {
263 		retries++;
264 		if (retries > XHI_MAX_RETRIES)
265 			break;
266 	}
267 
268 	dev_dbg(drvdata->dev, "done fifo_set_configuration\n");
269 
270 	/*
271 	 * If the requested number of words have not been read from
272 	 * the device then indicate failure.
273 	 */
274 	if (remaining_words != 0)
275 		return -EIO;
276 
277 	return 0;
278 }
279 
280 /**
281  * fifo_icap_get_configuration - Read configuration data from the device.
282  * @drvdata: a pointer to the drvdata.
283  * @data: Address of the data representing the partial bitstream
284  * @size: the size of the partial bitstream in 32 bit words.
285  *
286  * This function reads the specified number of words from the ICAP device in
287  * the polled mode.
288  */
289 int fifo_icap_get_configuration(struct hwicap_drvdata *drvdata,
290 		u32 *frame_buffer, u32 num_words)
291 {
292 
293 	u32 read_fifo_occupancy = 0;
294 	u32 retries = 0;
295 	u32 *data = frame_buffer;
296 	u32 remaining_words;
297 	u32 words_to_read;
298 
299 	dev_dbg(drvdata->dev, "fifo_get_configuration\n");
300 
301 	/*
302 	 * Check if the ICAP device is Busy with the last Write/Read
303 	 */
304 	if (fifo_icap_busy(drvdata))
305 		return -EBUSY;
306 
307 	remaining_words = num_words;
308 
309 	while (remaining_words > 0) {
310 		words_to_read = remaining_words;
311 		/* The hardware has a limit on the number of words
312 		   that can be read at one time.  */
313 		if (words_to_read > XHI_MAX_READ_TRANSACTION_WORDS)
314 			words_to_read = XHI_MAX_READ_TRANSACTION_WORDS;
315 
316 		remaining_words -= words_to_read;
317 
318 		fifo_icap_set_read_size(drvdata, words_to_read);
319 		fifo_icap_start_readback(drvdata);
320 
321 		while (words_to_read > 0) {
322 			/* Wait until we have some data in the fifo. */
323 			while (read_fifo_occupancy == 0) {
324 				read_fifo_occupancy =
325 					fifo_icap_read_fifo_occupancy(drvdata);
326 				retries++;
327 				if (retries > XHI_MAX_RETRIES)
328 					return -EIO;
329 			}
330 
331 			if (read_fifo_occupancy > words_to_read)
332 				read_fifo_occupancy = words_to_read;
333 
334 			words_to_read -= read_fifo_occupancy;
335 
336 			/* Read the data from the Read FIFO. */
337 			while (read_fifo_occupancy != 0) {
338 				*data++ = fifo_icap_fifo_read(drvdata);
339 				read_fifo_occupancy--;
340 			}
341 		}
342 	}
343 
344 	dev_dbg(drvdata->dev, "done fifo_get_configuration\n");
345 
346 	return 0;
347 }
348 
349 /**
350  * buffer_icap_reset - Reset the logic of the icap device.
351  * @drvdata: a pointer to the drvdata.
352  *
353  * This function forces the software reset of the complete HWICAP device.
354  * All the registers will return to the default value and the FIFO is also
355  * flushed as a part of this software reset.
356  */
357 void fifo_icap_reset(struct hwicap_drvdata *drvdata)
358 {
359 	u32 reg_data;
360 	/*
361 	 * Reset the device by setting/clearing the RESET bit in the
362 	 * Control Register.
363 	 */
364 	reg_data = in_be32(drvdata->base_address + XHI_CR_OFFSET);
365 
366 	out_be32(drvdata->base_address + XHI_CR_OFFSET,
367 				reg_data | XHI_CR_SW_RESET_MASK);
368 
369 	out_be32(drvdata->base_address + XHI_CR_OFFSET,
370 				reg_data & (~XHI_CR_SW_RESET_MASK));
371 
372 }
373 
374 /**
375  * fifo_icap_flush_fifo - This function flushes the FIFOs in the device.
376  * @drvdata: a pointer to the drvdata.
377  */
378 void fifo_icap_flush_fifo(struct hwicap_drvdata *drvdata)
379 {
380 	u32 reg_data;
381 	/*
382 	 * Flush the FIFO by setting/clearing the FIFO Clear bit in the
383 	 * Control Register.
384 	 */
385 	reg_data = in_be32(drvdata->base_address + XHI_CR_OFFSET);
386 
387 	out_be32(drvdata->base_address + XHI_CR_OFFSET,
388 				reg_data | XHI_CR_FIFO_CLR_MASK);
389 
390 	out_be32(drvdata->base_address + XHI_CR_OFFSET,
391 				reg_data & (~XHI_CR_FIFO_CLR_MASK));
392 }
393 
394