1 /***********************license start************************************
2  * Copyright (c) 2003-2017 Cavium, Inc.
3  * All rights reserved.
4  *
5  * License: one of 'Cavium License' or 'GNU General Public License Version 2'
6  *
7  * This file is provided under the terms of the Cavium License (see below)
8  * or under the terms of GNU General Public License, Version 2, as
9  * published by the Free Software Foundation. When using or redistributing
10  * this file, you may do so under either license.
11  *
12  * Cavium License:  Redistribution and use in source and binary forms, with
13  * or without modification, are permitted provided that the following
14  * conditions are met:
15  *
16  *  * Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  *
19  *  * Redistributions in binary form must reproduce the above
20  *    copyright notice, this list of conditions and the following
21  *    disclaimer in the documentation and/or other materials provided
22  *    with the distribution.
23  *
24  *  * Neither the name of Cavium Inc. nor the names of its contributors may be
25  *    used to endorse or promote products derived from this software without
26  *    specific prior written permission.
27  *
28  * This Software, including technical data, may be subject to U.S. export
29  * control laws, including the U.S. Export Administration Act and its
30  * associated regulations, and may be subject to export or import
31  * regulations in other countries.
32  *
33  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
34  * AND WITH ALL FAULTS AND CAVIUM INC. MAKES NO PROMISES, REPRESENTATIONS
35  * OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH
36  * RESPECT TO THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY
37  * REPRESENTATION OR DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT
38  * DEFECTS, AND CAVIUM SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY)
39  * WARRANTIES OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A
40  * PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET
41  * ENJOYMENT, QUIET POSSESSION OR CORRESPONDENCE TO DESCRIPTION. THE
42  * ENTIRE  RISK ARISING OUT OF USE OR PERFORMANCE OF THE SOFTWARE LIES
43  * WITH YOU.
44  ***********************license end**************************************/
45 
46 #include "common.h"
47 #include "zip_deflate.h"
48 
49 /**
50  * zip_cmd_queue_consumed - Calculates the space consumed in the command queue.
51  *
52  * @zip_dev: Pointer to zip device structure
53  * @queue:   Queue number
54  *
55  * Return: Bytes consumed in the command queue buffer.
56  */
57 static inline u32 zip_cmd_queue_consumed(struct zip_device *zip_dev, int queue)
58 {
59 	return ((zip_dev->iq[queue].sw_head - zip_dev->iq[queue].sw_tail) *
60 		sizeof(u64 *));
61 }
62 
63 /**
64  * zip_load_instr - Submits the instruction into the ZIP command queue
65  * @instr:      Pointer to the instruction to be submitted
66  * @zip_dev:    Pointer to ZIP device structure to which the instruction is to
67  *              be submitted
68  *
69  * This function copies the ZIP instruction to the command queue and rings the
70  * doorbell to notify the engine of the instruction submission. The command
71  * queue is maintained in a circular fashion. When there is space for exactly
72  * one instruction in the queue, next chunk pointer of the queue is made to
73  * point to the head of the queue, thus maintaining a circular queue.
74  *
75  * Return: Queue number to which the instruction was submitted
76  */
77 u32 zip_load_instr(union zip_inst_s *instr,
78 		   struct zip_device *zip_dev)
79 {
80 	union zip_quex_doorbell dbell;
81 	u32 queue = 0;
82 	u32 consumed = 0;
83 	u64 *ncb_ptr = NULL;
84 	union zip_nptr_s ncp;
85 
86 	/*
87 	 * Distribute the instructions between the enabled queues based on
88 	 * the CPU id.
89 	 */
90 	if (raw_smp_processor_id() % 2 == 0)
91 		queue = 0;
92 	else
93 		queue = 1;
94 
95 	zip_dbg("CPU Core: %d Queue number:%d", raw_smp_processor_id(), queue);
96 
97 	/* Take cmd buffer lock */
98 	spin_lock(&zip_dev->iq[queue].lock);
99 
100 	/*
101 	 * Command Queue implementation
102 	 * 1. If there is place for new instructions, push the cmd at sw_head.
103 	 * 2. If there is place for exactly one instruction, push the new cmd
104 	 *    at the sw_head. Make sw_head point to the sw_tail to make it
105 	 *    circular. Write sw_head's physical address to the "Next-Chunk
106 	 *    Buffer Ptr" to make it cmd_hw_tail.
107 	 * 3. Ring the door bell.
108 	 */
109 	zip_dbg("sw_head : %lx", zip_dev->iq[queue].sw_head);
110 	zip_dbg("sw_tail : %lx", zip_dev->iq[queue].sw_tail);
111 
112 	consumed = zip_cmd_queue_consumed(zip_dev, queue);
113 	/* Check if there is space to push just one cmd */
114 	if ((consumed + 128) == (ZIP_CMD_QBUF_SIZE - 8)) {
115 		zip_dbg("Cmd queue space available for single command");
116 		/* Space for one cmd, pust it and make it circular queue */
117 		memcpy((u8 *)zip_dev->iq[queue].sw_head, (u8 *)instr,
118 		       sizeof(union zip_inst_s));
119 		zip_dev->iq[queue].sw_head += 16; /* 16 64_bit words = 128B */
120 
121 		/* Now, point the "Next-Chunk Buffer Ptr" to sw_head */
122 		ncb_ptr = zip_dev->iq[queue].sw_head;
123 
124 		zip_dbg("ncb addr :0x%lx sw_head addr :0x%lx",
125 			ncb_ptr, zip_dev->iq[queue].sw_head - 16);
126 
127 		/* Using Circular command queue */
128 		zip_dev->iq[queue].sw_head = zip_dev->iq[queue].sw_tail;
129 		/* Mark this buffer for free */
130 		zip_dev->iq[queue].free_flag = 1;
131 
132 		/* Write new chunk buffer address at "Next-Chunk Buffer Ptr" */
133 		ncp.u_reg64 = 0ull;
134 		ncp.s.addr = __pa(zip_dev->iq[queue].sw_head);
135 		*ncb_ptr = ncp.u_reg64;
136 		zip_dbg("*ncb_ptr :0x%lx sw_head[phys] :0x%lx",
137 			*ncb_ptr, __pa(zip_dev->iq[queue].sw_head));
138 
139 		zip_dev->iq[queue].pend_cnt++;
140 
141 	} else {
142 		zip_dbg("Enough space is available for commands");
143 		/* Push this cmd to cmd queue buffer */
144 		memcpy((u8 *)zip_dev->iq[queue].sw_head, (u8 *)instr,
145 		       sizeof(union zip_inst_s));
146 		zip_dev->iq[queue].sw_head += 16; /* 16 64_bit words = 128B */
147 
148 		zip_dev->iq[queue].pend_cnt++;
149 	}
150 	zip_dbg("sw_head :0x%lx sw_tail :0x%lx hw_tail :0x%lx",
151 		zip_dev->iq[queue].sw_head, zip_dev->iq[queue].sw_tail,
152 		zip_dev->iq[queue].hw_tail);
153 
154 	zip_dbg(" Pushed the new cmd : pend_cnt : %d",
155 		zip_dev->iq[queue].pend_cnt);
156 
157 	/* Ring the doorbell */
158 	dbell.u_reg64     = 0ull;
159 	dbell.s.dbell_cnt = 1;
160 	zip_reg_write(dbell.u_reg64,
161 		      (zip_dev->reg_base + ZIP_QUEX_DOORBELL(queue)));
162 
163 	/* Unlock cmd buffer lock */
164 	spin_unlock(&zip_dev->iq[queue].lock);
165 
166 	return queue;
167 }
168 
169 /**
170  * zip_update_cmd_bufs - Updates the queue statistics after posting the
171  *                       instruction
172  * @zip_dev: Pointer to zip device structure
173  * @queue:   Queue number
174  */
175 void zip_update_cmd_bufs(struct zip_device *zip_dev, u32 queue)
176 {
177 	/* Take cmd buffer lock */
178 	spin_lock(&zip_dev->iq[queue].lock);
179 
180 	/* Check if the previous buffer can be freed */
181 	if (zip_dev->iq[queue].free_flag == 1) {
182 		zip_dbg("Free flag. Free cmd buffer, adjust sw head and tail");
183 		/* Reset the free flag */
184 		zip_dev->iq[queue].free_flag = 0;
185 
186 		/* Point the hw_tail to start of the new chunk buffer */
187 		zip_dev->iq[queue].hw_tail = zip_dev->iq[queue].sw_head;
188 	} else {
189 		zip_dbg("Free flag not set. increment hw tail");
190 		zip_dev->iq[queue].hw_tail += 16; /* 16 64_bit words = 128B */
191 	}
192 
193 	zip_dev->iq[queue].done_cnt++;
194 	zip_dev->iq[queue].pend_cnt--;
195 
196 	zip_dbg("sw_head :0x%lx sw_tail :0x%lx hw_tail :0x%lx",
197 		zip_dev->iq[queue].sw_head, zip_dev->iq[queue].sw_tail,
198 		zip_dev->iq[queue].hw_tail);
199 	zip_dbg(" Got CC : pend_cnt : %d\n", zip_dev->iq[queue].pend_cnt);
200 
201 	spin_unlock(&zip_dev->iq[queue].lock);
202 }
203