1 /*******************************************************************************
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 *
21 * Copyright 2014 QLogic Corporation
22 * The contents of this file are subject to the terms of the
23 * QLogic End User License (the "License").
24 * You may not use this file except in compliance with the License.
25 *
26 * You can obtain a copy of the License at
27 * http://www.qlogic.com/Resources/Documents/DriverDownloadHelp/
28 * QLogic_End_User_Software_License.txt
29 * See the License for the specific language governing permissions
30 * and limitations under the License.
31 *
32 *
33 * Module Description:
34 * This file contains general LM utility functions
35 *
36 ******************************************************************************/
37
38 #include "lm5710.h"
39
40 #ifdef _VBD_CMD_
41 #include "everest_sim.h"
42 #endif
43
44 #define MASK_01010101 (((unsigned int)(-1))/3)
45 #define MASK_00110011 (((unsigned int)(-1))/5)
46 #define MASK_00001111 (((unsigned int)(-1))/17)
47
count_bits(u32_t n)48 u32_t count_bits(u32_t n)
49 {
50 n = (n & MASK_01010101) + ((n >> 1) & MASK_01010101) ;
51 n = (n & MASK_00110011) + ((n >> 2) & MASK_00110011) ;
52 n = (n & MASK_00001111) + ((n >> 4) & MASK_00001111) ;
53
54 return n % 255 ;
55 }
56
log2_align(unsigned long n)57 unsigned long log2_align(unsigned long n)
58 {
59 unsigned long ret = n ? 1 : 0;
60 unsigned long _n = n >> 1;
61
62 while (_n)
63 {
64 _n >>= 1;
65 ret <<= 1;
66 }
67
68 if (ret < n)
69 ret <<= 1;
70
71 return ret;
72 }
73 /**
74 * @description
75 * Should be moved to a common file.
76 * Calculates the lower align of power 2.
77 * Values lower than 0 are returned directly.
78 * @param n
79 *
80 * @return unsigned long
81 * lower align of power 2.
82 */
power2_lower_align(unsigned long n)83 unsigned long power2_lower_align(unsigned long n)
84 {
85 unsigned long ret = 0;
86 if(0 == n)
87 {
88 return 0;
89 }
90
91 if(TRUE == POWER_OF_2(n))
92 {
93 // The number is already a power of 2.
94 return n;
95 }
96
97 //Calculates the lower align of power 2.
98 ret = log2_align(n);
99 DbgBreakIf(FALSE == POWER_OF_2(ret));
100 ret >>= 1;
101
102 return ret;
103 }
104 /*
105 Log2
106 this function calculates rounded LOG2 of a certain number
107 e.g.: LOG2(1080) = 10 (2^10=1024)
108 */
LOG2(u32_t v)109 u32_t LOG2(u32_t v){
110 u32_t r=0;
111 while (v >>= 1) {
112 r++;
113 }
114 return r;
115 }
116
117 /**
118 * @description
119 * Should be moved to a common place.
120 * Find the next power of 2 that is larger than "num".
121 * @param num - The variable to find a power of 2 that is
122 * larger.
123 * @param num_bits_supported - The largest number of bits
124 * supported
125 *
126 * @return u32_t - The next power of 2 that is larger than
127 * "num".
128 */
129 u32_t
upper_align_power_of_2(IN const u16_t num,IN const u8_t num_bits_supported)130 upper_align_power_of_2(IN const u16_t num,
131 IN const u8_t num_bits_supported)
132 {
133 u32_t const largest_power_of_2 = 1 << (num_bits_supported - 1);
134 u32_t prev_power_of_2 = largest_power_of_2;
135 u32_t cur_power_of_2 = 0;
136 u8_t i = 0;
137
138 //This is not realy needed (the for also handles this case) but to avoide confusing
139 if(num >= largest_power_of_2)
140 {
141 DbgBreakMsg("num is larger than num_bits_supported");
142 return largest_power_of_2;
143 }
144 // Exception case
145 if(0 == num)
146 {
147 return 1;
148 }
149
150 // Look for a value that is smaller than prev_power_of_2 and bigger than cur_power_of_2
151 for (i = (num_bits_supported - 1) ; i != 0 ;i--)
152 {
153 cur_power_of_2 = 1 << (i);
154 if(num > cur_power_of_2)
155 {
156 break;
157 }
158 prev_power_of_2 = cur_power_of_2;
159 }
160 return prev_power_of_2;
161 }
162
163 /**
164 * General function that waits for a certain state to change,
165 * not protocol specific. It takes into account vbd-commander
166 * and reset-is-in-progress
167 *
168 * @param pdev
169 * @param curr_state -> what to poll on
170 * @param new_state -> what we're waiting for
171 *
172 * @return lm_status_t TIMEOUT if state didn't change, SUCCESS
173 * otherwise
174 */
175
176
177 /**
178 * @param pdev
179 *
180 * @return 0 if device is ASIC.
181 */
lm_chip_is_slow(struct _lm_device_t * pdev)182 int lm_chip_is_slow(struct _lm_device_t *pdev)
183 {
184 u32_t val = 0;
185
186 lm_reg_rd_ind(pdev, MISC_REG_CHIP_REV, &val);
187
188 val = (val & 0xf) << 12;
189
190 if (val > CHIP_REV_Cx) {
191 DbgMessage(pdev, VERBOSEi, "Chip is slow\n");
192 return 1;
193 } else {
194 return 0;
195 }
196 }
197
lm_wait_state_change(struct _lm_device_t * pdev,volatile u32_t * curr_state,u32_t new_state)198 lm_status_t lm_wait_state_change(struct _lm_device_t *pdev, volatile u32_t * curr_state, u32_t new_state)
199 {
200 u32_t delay_us = 0;
201 u32_t to_cnt = 10000 + 2360; // We'll wait 10,000 times 100us (1 second) + 2360 times 25000us (59sec) = total 60 sec
202 // (Winodws only note) the 25000 wait will cause wait to be without CPU stall (look in win_util.c)
203 lm_status_t lm_status = LM_STATUS_SUCCESS;
204
205
206 #ifdef _VBD_CMD_
207 if (!GET_FLAGS(*g_everest_sim_flags_ptr, EVEREST_SIM_RAMROD))
208 {
209 *curr_state = new_state;
210 return lm_status;
211 }
212 #endif
213
214
215 /* wait for state change */
216 while ((*curr_state != new_state) && to_cnt--)
217 {
218 delay_us = (to_cnt >= 2360) ? 100 : 25000 ;
219 mm_wait(pdev, delay_us);
220
221 #ifdef DOS
222 sleep(0); // rescheduling threads, since we don't have a memory barrier.
223 #elif defined(__LINUX)
224 mm_read_barrier(); // synchronize on eth_con->con_state
225 #endif
226
227 // in case reset in progress
228 // we won't get completion so no need to wait
229 if( lm_reset_is_inprogress(pdev) )
230 {
231 lm_status = LM_STATUS_ABORTED;
232 break;
233 }
234 }
235
236 if ( *curr_state != new_state)
237 {
238 DbgMessage(pdev, FATAL,
239 "lm_wait_state_change: state change timeout, curr state=%d, expected new state=%d!\n",
240 *curr_state, new_state);
241 if (!lm_reset_is_inprogress(pdev)) {
242 #if defined(_VBD_)
243 DbgBreak();
244 #endif
245 lm_status = LM_STATUS_TIMEOUT;
246 }
247 }
248
249 return lm_status;
250 }
251
252 /*******************************************************************************
253 * Description:
254 * Calculates crc 32 on a buffer
255 * Note: crc32_length MUST be aligned to 8
256 * Return:
257 ******************************************************************************/
calc_crc32(u8_t * crc32_packet,u32_t crc32_length,u32_t crc32_seed,u8_t complement)258 u32_t calc_crc32( u8_t* crc32_packet, u32_t crc32_length, u32_t crc32_seed, u8_t complement)
259 {
260 u32_t byte = 0 ;
261 u32_t bit = 0 ;
262 u8_t msb = 0 ; // 1
263 u32_t temp = 0 ;
264 u32_t shft = 0 ;
265 u8_t current_byte = 0 ;
266 u32_t crc32_result = crc32_seed;
267 const u32_t CRC32_POLY = 0x1edc6f41;
268 if( CHK_NULL( crc32_packet) || ERR_IF( 0 == crc32_length ) || ERR_IF( 0 != ( crc32_length % 8 ) ) )
269 {
270 return crc32_result ;
271 }
272 for (byte = 0; byte < crc32_length; byte = byte + 1)
273 {
274 current_byte = crc32_packet[byte];
275 for (bit = 0; bit < 8; bit = bit + 1)
276 {
277 msb = (u8_t)(crc32_result >> 31) ; // msb = crc32_result[31];
278 crc32_result = crc32_result << 1;
279 if ( msb != ( 0x1 & (current_byte>>bit)) ) // (msb != current_byte[bit])
280 {
281 crc32_result = crc32_result ^ CRC32_POLY;
282 crc32_result |= 1 ;//crc32_result[0] = 1;
283 }
284 }
285 }
286 // Last step is to "mirror" every bit, swap the 4 bytes, and then complement each bit.
287 //
288 // Mirror:
289 temp = crc32_result ;
290 shft = sizeof(crc32_result) * 8 -1 ;
291 for( crc32_result>>= 1; crc32_result; crc32_result>>= 1 )
292 {
293 temp <<= 1;
294 temp |= crc32_result & 1;
295 shft-- ;
296 }
297 temp <<= shft ;
298 //temp[31-bit] = crc32_result[bit];
299 // Swap:
300 // crc32_result = {temp[7:0], temp[15:8], temp[23:16], temp[31:24]};
301 {
302 u32_t t0, t1, t2, t3 ;
303 t0 = ( ( 0x000000ff ) & ( temp >> 24 ) ) ; // temp >> 24 ;
304 t1 = ( ( 0x0000ff00 ) & ( temp >> 8 ) ) ;
305 t2 = ( ( 0x00ff0000 ) & ( temp << 8 ) ) ;
306 t3 = ( ( 0xff000000 ) & ( temp << 24 ) ) ;
307 crc32_result = t0 | t1 | t2 | t3 ;
308 }
309 // Complement:
310 if (complement)
311 {
312 crc32_result = ~crc32_result ;
313 }
314 return crc32_result ;
315 }
316
317 /**
318 * @brief: convert 4 bytes version into 32 bit BCD formatted version
319 *
320 * 1. Format the product_version string:
321 * a. The "Major, "Minor, "Build and "Sub build" bytes are BCD-encoded, and each byte holds two BCD digits.
322 * b. The semantics of these fields follow the semantics specified in DSP4004.
323 * c. The value 0xF in the most-significant nibble of a BCD-encoded value indicates that the most significant nibble should be ignored and the overall field treated as a single digit value.
324 * d. A value of 0xFF indicates that the entire field is not present. 0xFF is not allowed as a value for the fields.
325 * Example: Version 3.7.10.FF --> 0xF3F710FF
326 *
327
328 * @param[in] CONST u8_t IN ver_arr[4]
329 *
330 * @return u32_t value
331 */
332 u32_t
convert_to_bcd(const u8_t IN ver_arr[4])333 convert_to_bcd( const u8_t IN ver_arr[4] )
334 {
335 u32_t ver_32 = 0xffffffff;
336 u8_t idx = 0;
337 u8_t ver_current = 0;
338
339 if ( ver_arr )
340 {
341 ver_32 = 0;
342
343 // convert to BCD format
344 // We have for sure 4 digits only
345 // ARRSIZE(ver_arr) won't work here since in non x86 compile it is NOT 4....
346 for( idx = 0; idx < 4; idx++ )
347 {
348 ver_current = ver_arr[idx];
349 if ( 0 == ( ver_current & 0xf0 ) )
350 {
351 ver_current |= 0xf0 ;
352 }
353 ver_32 = ( ver_32<<8 ) | ver_current ;
354 }
355 }
356
357 return ver_32;
358 }
359