utmath.c revision 1.1 1 1.1 jruoho /*******************************************************************************
2 1.1 jruoho *
3 1.1 jruoho * Module Name: utmath - Integer math support routines
4 1.1 jruoho *
5 1.1 jruoho ******************************************************************************/
6 1.1 jruoho
7 1.1 jruoho /******************************************************************************
8 1.1 jruoho *
9 1.1 jruoho * 1. Copyright Notice
10 1.1 jruoho *
11 1.1 jruoho * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
12 1.1 jruoho * All rights reserved.
13 1.1 jruoho *
14 1.1 jruoho * 2. License
15 1.1 jruoho *
16 1.1 jruoho * 2.1. This is your license from Intel Corp. under its intellectual property
17 1.1 jruoho * rights. You may have additional license terms from the party that provided
18 1.1 jruoho * you this software, covering your right to use that party's intellectual
19 1.1 jruoho * property rights.
20 1.1 jruoho *
21 1.1 jruoho * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 1.1 jruoho * copy of the source code appearing in this file ("Covered Code") an
23 1.1 jruoho * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 1.1 jruoho * base code distributed originally by Intel ("Original Intel Code") to copy,
25 1.1 jruoho * make derivatives, distribute, use and display any portion of the Covered
26 1.1 jruoho * Code in any form, with the right to sublicense such rights; and
27 1.1 jruoho *
28 1.1 jruoho * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 1.1 jruoho * license (with the right to sublicense), under only those claims of Intel
30 1.1 jruoho * patents that are infringed by the Original Intel Code, to make, use, sell,
31 1.1 jruoho * offer to sell, and import the Covered Code and derivative works thereof
32 1.1 jruoho * solely to the minimum extent necessary to exercise the above copyright
33 1.1 jruoho * license, and in no event shall the patent license extend to any additions
34 1.1 jruoho * to or modifications of the Original Intel Code. No other license or right
35 1.1 jruoho * is granted directly or by implication, estoppel or otherwise;
36 1.1 jruoho *
37 1.1 jruoho * The above copyright and patent license is granted only if the following
38 1.1 jruoho * conditions are met:
39 1.1 jruoho *
40 1.1 jruoho * 3. Conditions
41 1.1 jruoho *
42 1.1 jruoho * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 1.1 jruoho * Redistribution of source code of any substantial portion of the Covered
44 1.1 jruoho * Code or modification with rights to further distribute source must include
45 1.1 jruoho * the above Copyright Notice, the above License, this list of Conditions,
46 1.1 jruoho * and the following Disclaimer and Export Compliance provision. In addition,
47 1.1 jruoho * Licensee must cause all Covered Code to which Licensee contributes to
48 1.1 jruoho * contain a file documenting the changes Licensee made to create that Covered
49 1.1 jruoho * Code and the date of any change. Licensee must include in that file the
50 1.1 jruoho * documentation of any changes made by any predecessor Licensee. Licensee
51 1.1 jruoho * must include a prominent statement that the modification is derived,
52 1.1 jruoho * directly or indirectly, from Original Intel Code.
53 1.1 jruoho *
54 1.1 jruoho * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 1.1 jruoho * Redistribution of source code of any substantial portion of the Covered
56 1.1 jruoho * Code or modification without rights to further distribute source must
57 1.1 jruoho * include the following Disclaimer and Export Compliance provision in the
58 1.1 jruoho * documentation and/or other materials provided with distribution. In
59 1.1 jruoho * addition, Licensee may not authorize further sublicense of source of any
60 1.1 jruoho * portion of the Covered Code, and must include terms to the effect that the
61 1.1 jruoho * license from Licensee to its licensee is limited to the intellectual
62 1.1 jruoho * property embodied in the software Licensee provides to its licensee, and
63 1.1 jruoho * not to intellectual property embodied in modifications its licensee may
64 1.1 jruoho * make.
65 1.1 jruoho *
66 1.1 jruoho * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 1.1 jruoho * substantial portion of the Covered Code or modification must reproduce the
68 1.1 jruoho * above Copyright Notice, and the following Disclaimer and Export Compliance
69 1.1 jruoho * provision in the documentation and/or other materials provided with the
70 1.1 jruoho * distribution.
71 1.1 jruoho *
72 1.1 jruoho * 3.4. Intel retains all right, title, and interest in and to the Original
73 1.1 jruoho * Intel Code.
74 1.1 jruoho *
75 1.1 jruoho * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 1.1 jruoho * Intel shall be used in advertising or otherwise to promote the sale, use or
77 1.1 jruoho * other dealings in products derived from or relating to the Covered Code
78 1.1 jruoho * without prior written authorization from Intel.
79 1.1 jruoho *
80 1.1 jruoho * 4. Disclaimer and Export Compliance
81 1.1 jruoho *
82 1.1 jruoho * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 1.1 jruoho * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 1.1 jruoho * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 1.1 jruoho * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 1.1 jruoho * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 1.1 jruoho * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 1.1 jruoho * PARTICULAR PURPOSE.
89 1.1 jruoho *
90 1.1 jruoho * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 1.1 jruoho * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 1.1 jruoho * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 1.1 jruoho * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 1.1 jruoho * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 1.1 jruoho * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 1.1 jruoho * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 1.1 jruoho * LIMITED REMEDY.
98 1.1 jruoho *
99 1.1 jruoho * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 1.1 jruoho * software or system incorporating such software without first obtaining any
101 1.1 jruoho * required license or other approval from the U. S. Department of Commerce or
102 1.1 jruoho * any other agency or department of the United States Government. In the
103 1.1 jruoho * event Licensee exports any such software from the United States or
104 1.1 jruoho * re-exports any such software from a foreign destination, Licensee shall
105 1.1 jruoho * ensure that the distribution and export/re-export of the software is in
106 1.1 jruoho * compliance with all laws, regulations, orders, or other restrictions of the
107 1.1 jruoho * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 1.1 jruoho * any of its subsidiaries will export/re-export any technical data, process,
109 1.1 jruoho * software, or service, directly or indirectly, to any country for which the
110 1.1 jruoho * United States government or any agency thereof requires an export license,
111 1.1 jruoho * other governmental approval, or letter of assurance, without first obtaining
112 1.1 jruoho * such license, approval or letter.
113 1.1 jruoho *
114 1.1 jruoho *****************************************************************************/
115 1.1 jruoho
116 1.1 jruoho
117 1.1 jruoho #define __UTMATH_C__
118 1.1 jruoho
119 1.1 jruoho #include "acpi.h"
120 1.1 jruoho #include "accommon.h"
121 1.1 jruoho
122 1.1 jruoho
123 1.1 jruoho #define _COMPONENT ACPI_UTILITIES
124 1.1 jruoho ACPI_MODULE_NAME ("utmath")
125 1.1 jruoho
126 1.1 jruoho /*
127 1.1 jruoho * Support for double-precision integer divide. This code is included here
128 1.1 jruoho * in order to support kernel environments where the double-precision math
129 1.1 jruoho * library is not available.
130 1.1 jruoho */
131 1.1 jruoho
132 1.1 jruoho #ifndef ACPI_USE_NATIVE_DIVIDE
133 1.1 jruoho /*******************************************************************************
134 1.1 jruoho *
135 1.1 jruoho * FUNCTION: AcpiUtShortDivide
136 1.1 jruoho *
137 1.1 jruoho * PARAMETERS: Dividend - 64-bit dividend
138 1.1 jruoho * Divisor - 32-bit divisor
139 1.1 jruoho * OutQuotient - Pointer to where the quotient is returned
140 1.1 jruoho * OutRemainder - Pointer to where the remainder is returned
141 1.1 jruoho *
142 1.1 jruoho * RETURN: Status (Checks for divide-by-zero)
143 1.1 jruoho *
144 1.1 jruoho * DESCRIPTION: Perform a short (maximum 64 bits divided by 32 bits)
145 1.1 jruoho * divide and modulo. The result is a 64-bit quotient and a
146 1.1 jruoho * 32-bit remainder.
147 1.1 jruoho *
148 1.1 jruoho ******************************************************************************/
149 1.1 jruoho
150 1.1 jruoho ACPI_STATUS
151 1.1 jruoho AcpiUtShortDivide (
152 1.1 jruoho UINT64 Dividend,
153 1.1 jruoho UINT32 Divisor,
154 1.1 jruoho UINT64 *OutQuotient,
155 1.1 jruoho UINT32 *OutRemainder)
156 1.1 jruoho {
157 1.1 jruoho UINT64_OVERLAY DividendOvl;
158 1.1 jruoho UINT64_OVERLAY Quotient;
159 1.1 jruoho UINT32 Remainder32;
160 1.1 jruoho
161 1.1 jruoho
162 1.1 jruoho ACPI_FUNCTION_TRACE (UtShortDivide);
163 1.1 jruoho
164 1.1 jruoho
165 1.1 jruoho /* Always check for a zero divisor */
166 1.1 jruoho
167 1.1 jruoho if (Divisor == 0)
168 1.1 jruoho {
169 1.1 jruoho ACPI_ERROR ((AE_INFO, "Divide by zero"));
170 1.1 jruoho return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
171 1.1 jruoho }
172 1.1 jruoho
173 1.1 jruoho DividendOvl.Full = Dividend;
174 1.1 jruoho
175 1.1 jruoho /*
176 1.1 jruoho * The quotient is 64 bits, the remainder is always 32 bits,
177 1.1 jruoho * and is generated by the second divide.
178 1.1 jruoho */
179 1.1 jruoho ACPI_DIV_64_BY_32 (0, DividendOvl.Part.Hi, Divisor,
180 1.1 jruoho Quotient.Part.Hi, Remainder32);
181 1.1 jruoho ACPI_DIV_64_BY_32 (Remainder32, DividendOvl.Part.Lo, Divisor,
182 1.1 jruoho Quotient.Part.Lo, Remainder32);
183 1.1 jruoho
184 1.1 jruoho /* Return only what was requested */
185 1.1 jruoho
186 1.1 jruoho if (OutQuotient)
187 1.1 jruoho {
188 1.1 jruoho *OutQuotient = Quotient.Full;
189 1.1 jruoho }
190 1.1 jruoho if (OutRemainder)
191 1.1 jruoho {
192 1.1 jruoho *OutRemainder = Remainder32;
193 1.1 jruoho }
194 1.1 jruoho
195 1.1 jruoho return_ACPI_STATUS (AE_OK);
196 1.1 jruoho }
197 1.1 jruoho
198 1.1 jruoho
199 1.1 jruoho /*******************************************************************************
200 1.1 jruoho *
201 1.1 jruoho * FUNCTION: AcpiUtDivide
202 1.1 jruoho *
203 1.1 jruoho * PARAMETERS: InDividend - Dividend
204 1.1 jruoho * InDivisor - Divisor
205 1.1 jruoho * OutQuotient - Pointer to where the quotient is returned
206 1.1 jruoho * OutRemainder - Pointer to where the remainder is returned
207 1.1 jruoho *
208 1.1 jruoho * RETURN: Status (Checks for divide-by-zero)
209 1.1 jruoho *
210 1.1 jruoho * DESCRIPTION: Perform a divide and modulo.
211 1.1 jruoho *
212 1.1 jruoho ******************************************************************************/
213 1.1 jruoho
214 1.1 jruoho ACPI_STATUS
215 1.1 jruoho AcpiUtDivide (
216 1.1 jruoho UINT64 InDividend,
217 1.1 jruoho UINT64 InDivisor,
218 1.1 jruoho UINT64 *OutQuotient,
219 1.1 jruoho UINT64 *OutRemainder)
220 1.1 jruoho {
221 1.1 jruoho UINT64_OVERLAY Dividend;
222 1.1 jruoho UINT64_OVERLAY Divisor;
223 1.1 jruoho UINT64_OVERLAY Quotient;
224 1.1 jruoho UINT64_OVERLAY Remainder;
225 1.1 jruoho UINT64_OVERLAY NormalizedDividend;
226 1.1 jruoho UINT64_OVERLAY NormalizedDivisor;
227 1.1 jruoho UINT32 Partial1;
228 1.1 jruoho UINT64_OVERLAY Partial2;
229 1.1 jruoho UINT64_OVERLAY Partial3;
230 1.1 jruoho
231 1.1 jruoho
232 1.1 jruoho ACPI_FUNCTION_TRACE (UtDivide);
233 1.1 jruoho
234 1.1 jruoho
235 1.1 jruoho /* Always check for a zero divisor */
236 1.1 jruoho
237 1.1 jruoho if (InDivisor == 0)
238 1.1 jruoho {
239 1.1 jruoho ACPI_ERROR ((AE_INFO, "Divide by zero"));
240 1.1 jruoho return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
241 1.1 jruoho }
242 1.1 jruoho
243 1.1 jruoho Divisor.Full = InDivisor;
244 1.1 jruoho Dividend.Full = InDividend;
245 1.1 jruoho if (Divisor.Part.Hi == 0)
246 1.1 jruoho {
247 1.1 jruoho /*
248 1.1 jruoho * 1) Simplest case is where the divisor is 32 bits, we can
249 1.1 jruoho * just do two divides
250 1.1 jruoho */
251 1.1 jruoho Remainder.Part.Hi = 0;
252 1.1 jruoho
253 1.1 jruoho /*
254 1.1 jruoho * The quotient is 64 bits, the remainder is always 32 bits,
255 1.1 jruoho * and is generated by the second divide.
256 1.1 jruoho */
257 1.1 jruoho ACPI_DIV_64_BY_32 (0, Dividend.Part.Hi, Divisor.Part.Lo,
258 1.1 jruoho Quotient.Part.Hi, Partial1);
259 1.1 jruoho ACPI_DIV_64_BY_32 (Partial1, Dividend.Part.Lo, Divisor.Part.Lo,
260 1.1 jruoho Quotient.Part.Lo, Remainder.Part.Lo);
261 1.1 jruoho }
262 1.1 jruoho
263 1.1 jruoho else
264 1.1 jruoho {
265 1.1 jruoho /*
266 1.1 jruoho * 2) The general case where the divisor is a full 64 bits
267 1.1 jruoho * is more difficult
268 1.1 jruoho */
269 1.1 jruoho Quotient.Part.Hi = 0;
270 1.1 jruoho NormalizedDividend = Dividend;
271 1.1 jruoho NormalizedDivisor = Divisor;
272 1.1 jruoho
273 1.1 jruoho /* Normalize the operands (shift until the divisor is < 32 bits) */
274 1.1 jruoho
275 1.1 jruoho do
276 1.1 jruoho {
277 1.1 jruoho ACPI_SHIFT_RIGHT_64 (NormalizedDivisor.Part.Hi,
278 1.1 jruoho NormalizedDivisor.Part.Lo);
279 1.1 jruoho ACPI_SHIFT_RIGHT_64 (NormalizedDividend.Part.Hi,
280 1.1 jruoho NormalizedDividend.Part.Lo);
281 1.1 jruoho
282 1.1 jruoho } while (NormalizedDivisor.Part.Hi != 0);
283 1.1 jruoho
284 1.1 jruoho /* Partial divide */
285 1.1 jruoho
286 1.1 jruoho ACPI_DIV_64_BY_32 (NormalizedDividend.Part.Hi,
287 1.1 jruoho NormalizedDividend.Part.Lo,
288 1.1 jruoho NormalizedDivisor.Part.Lo,
289 1.1 jruoho Quotient.Part.Lo, Partial1);
290 1.1 jruoho
291 1.1 jruoho /*
292 1.1 jruoho * The quotient is always 32 bits, and simply requires adjustment.
293 1.1 jruoho * The 64-bit remainder must be generated.
294 1.1 jruoho */
295 1.1 jruoho Partial1 = Quotient.Part.Lo * Divisor.Part.Hi;
296 1.1 jruoho Partial2.Full = (UINT64) Quotient.Part.Lo * Divisor.Part.Lo;
297 1.1 jruoho Partial3.Full = (UINT64) Partial2.Part.Hi + Partial1;
298 1.1 jruoho
299 1.1 jruoho Remainder.Part.Hi = Partial3.Part.Lo;
300 1.1 jruoho Remainder.Part.Lo = Partial2.Part.Lo;
301 1.1 jruoho
302 1.1 jruoho if (Partial3.Part.Hi == 0)
303 1.1 jruoho {
304 1.1 jruoho if (Partial3.Part.Lo >= Dividend.Part.Hi)
305 1.1 jruoho {
306 1.1 jruoho if (Partial3.Part.Lo == Dividend.Part.Hi)
307 1.1 jruoho {
308 1.1 jruoho if (Partial2.Part.Lo > Dividend.Part.Lo)
309 1.1 jruoho {
310 1.1 jruoho Quotient.Part.Lo--;
311 1.1 jruoho Remainder.Full -= Divisor.Full;
312 1.1 jruoho }
313 1.1 jruoho }
314 1.1 jruoho else
315 1.1 jruoho {
316 1.1 jruoho Quotient.Part.Lo--;
317 1.1 jruoho Remainder.Full -= Divisor.Full;
318 1.1 jruoho }
319 1.1 jruoho }
320 1.1 jruoho
321 1.1 jruoho Remainder.Full = Remainder.Full - Dividend.Full;
322 1.1 jruoho Remainder.Part.Hi = (UINT32) -((INT32) Remainder.Part.Hi);
323 1.1 jruoho Remainder.Part.Lo = (UINT32) -((INT32) Remainder.Part.Lo);
324 1.1 jruoho
325 1.1 jruoho if (Remainder.Part.Lo)
326 1.1 jruoho {
327 1.1 jruoho Remainder.Part.Hi--;
328 1.1 jruoho }
329 1.1 jruoho }
330 1.1 jruoho }
331 1.1 jruoho
332 1.1 jruoho /* Return only what was requested */
333 1.1 jruoho
334 1.1 jruoho if (OutQuotient)
335 1.1 jruoho {
336 1.1 jruoho *OutQuotient = Quotient.Full;
337 1.1 jruoho }
338 1.1 jruoho if (OutRemainder)
339 1.1 jruoho {
340 1.1 jruoho *OutRemainder = Remainder.Full;
341 1.1 jruoho }
342 1.1 jruoho
343 1.1 jruoho return_ACPI_STATUS (AE_OK);
344 1.1 jruoho }
345 1.1 jruoho
346 1.1 jruoho #else
347 1.1 jruoho
348 1.1 jruoho /*******************************************************************************
349 1.1 jruoho *
350 1.1 jruoho * FUNCTION: AcpiUtShortDivide, AcpiUtDivide
351 1.1 jruoho *
352 1.1 jruoho * PARAMETERS: See function headers above
353 1.1 jruoho *
354 1.1 jruoho * DESCRIPTION: Native versions of the UtDivide functions. Use these if either
355 1.1 jruoho * 1) The target is a 64-bit platform and therefore 64-bit
356 1.1 jruoho * integer math is supported directly by the machine.
357 1.1 jruoho * 2) The target is a 32-bit or 16-bit platform, and the
358 1.1 jruoho * double-precision integer math library is available to
359 1.1 jruoho * perform the divide.
360 1.1 jruoho *
361 1.1 jruoho ******************************************************************************/
362 1.1 jruoho
363 1.1 jruoho ACPI_STATUS
364 1.1 jruoho AcpiUtShortDivide (
365 1.1 jruoho UINT64 InDividend,
366 1.1 jruoho UINT32 Divisor,
367 1.1 jruoho UINT64 *OutQuotient,
368 1.1 jruoho UINT32 *OutRemainder)
369 1.1 jruoho {
370 1.1 jruoho
371 1.1 jruoho ACPI_FUNCTION_TRACE (UtShortDivide);
372 1.1 jruoho
373 1.1 jruoho
374 1.1 jruoho /* Always check for a zero divisor */
375 1.1 jruoho
376 1.1 jruoho if (Divisor == 0)
377 1.1 jruoho {
378 1.1 jruoho ACPI_ERROR ((AE_INFO, "Divide by zero"));
379 1.1 jruoho return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
380 1.1 jruoho }
381 1.1 jruoho
382 1.1 jruoho /* Return only what was requested */
383 1.1 jruoho
384 1.1 jruoho if (OutQuotient)
385 1.1 jruoho {
386 1.1 jruoho *OutQuotient = InDividend / Divisor;
387 1.1 jruoho }
388 1.1 jruoho if (OutRemainder)
389 1.1 jruoho {
390 1.1 jruoho *OutRemainder = (UINT32) (InDividend % Divisor);
391 1.1 jruoho }
392 1.1 jruoho
393 1.1 jruoho return_ACPI_STATUS (AE_OK);
394 1.1 jruoho }
395 1.1 jruoho
396 1.1 jruoho ACPI_STATUS
397 1.1 jruoho AcpiUtDivide (
398 1.1 jruoho UINT64 InDividend,
399 1.1 jruoho UINT64 InDivisor,
400 1.1 jruoho UINT64 *OutQuotient,
401 1.1 jruoho UINT64 *OutRemainder)
402 1.1 jruoho {
403 1.1 jruoho ACPI_FUNCTION_TRACE (UtDivide);
404 1.1 jruoho
405 1.1 jruoho
406 1.1 jruoho /* Always check for a zero divisor */
407 1.1 jruoho
408 1.1 jruoho if (InDivisor == 0)
409 1.1 jruoho {
410 1.1 jruoho ACPI_ERROR ((AE_INFO, "Divide by zero"));
411 1.1 jruoho return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
412 1.1 jruoho }
413 1.1 jruoho
414 1.1 jruoho
415 1.1 jruoho /* Return only what was requested */
416 1.1 jruoho
417 1.1 jruoho if (OutQuotient)
418 1.1 jruoho {
419 1.1 jruoho *OutQuotient = InDividend / InDivisor;
420 1.1 jruoho }
421 1.1 jruoho if (OutRemainder)
422 1.1 jruoho {
423 1.1 jruoho *OutRemainder = InDividend % InDivisor;
424 1.1 jruoho }
425 1.1 jruoho
426 1.1 jruoho return_ACPI_STATUS (AE_OK);
427 1.1 jruoho }
428 1.1 jruoho
429 1.1 jruoho #endif
430 1.1 jruoho
431 1.1 jruoho
432