13446Smrj /******************************************************************************* 23446Smrj * 33446Smrj * Module Name: utmath - Integer math support routines 43446Smrj * 53446Smrj ******************************************************************************/ 63446Smrj 73446Smrj /****************************************************************************** 83446Smrj * 93446Smrj * 1. Copyright Notice 103446Smrj * 11*9980SDana.Myers@Sun.COM * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp. 123446Smrj * All rights reserved. 133446Smrj * 143446Smrj * 2. License 153446Smrj * 163446Smrj * 2.1. This is your license from Intel Corp. under its intellectual property 173446Smrj * rights. You may have additional license terms from the party that provided 183446Smrj * you this software, covering your right to use that party's intellectual 193446Smrj * property rights. 203446Smrj * 213446Smrj * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 223446Smrj * copy of the source code appearing in this file ("Covered Code") an 233446Smrj * irrevocable, perpetual, worldwide license under Intel's copyrights in the 243446Smrj * base code distributed originally by Intel ("Original Intel Code") to copy, 253446Smrj * make derivatives, distribute, use and display any portion of the Covered 263446Smrj * Code in any form, with the right to sublicense such rights; and 273446Smrj * 283446Smrj * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 293446Smrj * license (with the right to sublicense), under only those claims of Intel 303446Smrj * patents that are infringed by the Original Intel Code, to make, use, sell, 313446Smrj * offer to sell, and import the Covered Code and derivative works thereof 323446Smrj * solely to the minimum extent necessary to exercise the above copyright 333446Smrj * license, and in no event shall the patent license extend to any additions 343446Smrj * to or modifications of the Original Intel Code. No other license or right 353446Smrj * is granted directly or by implication, estoppel or otherwise; 363446Smrj * 373446Smrj * The above copyright and patent license is granted only if the following 383446Smrj * conditions are met: 393446Smrj * 403446Smrj * 3. Conditions 413446Smrj * 423446Smrj * 3.1. Redistribution of Source with Rights to Further Distribute Source. 433446Smrj * Redistribution of source code of any substantial portion of the Covered 443446Smrj * Code or modification with rights to further distribute source must include 453446Smrj * the above Copyright Notice, the above License, this list of Conditions, 463446Smrj * and the following Disclaimer and Export Compliance provision. In addition, 473446Smrj * Licensee must cause all Covered Code to which Licensee contributes to 483446Smrj * contain a file documenting the changes Licensee made to create that Covered 493446Smrj * Code and the date of any change. Licensee must include in that file the 503446Smrj * documentation of any changes made by any predecessor Licensee. Licensee 513446Smrj * must include a prominent statement that the modification is derived, 523446Smrj * directly or indirectly, from Original Intel Code. 533446Smrj * 543446Smrj * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 553446Smrj * Redistribution of source code of any substantial portion of the Covered 563446Smrj * Code or modification without rights to further distribute source must 573446Smrj * include the following Disclaimer and Export Compliance provision in the 583446Smrj * documentation and/or other materials provided with distribution. In 593446Smrj * addition, Licensee may not authorize further sublicense of source of any 603446Smrj * portion of the Covered Code, and must include terms to the effect that the 613446Smrj * license from Licensee to its licensee is limited to the intellectual 623446Smrj * property embodied in the software Licensee provides to its licensee, and 633446Smrj * not to intellectual property embodied in modifications its licensee may 643446Smrj * make. 653446Smrj * 663446Smrj * 3.3. Redistribution of Executable. Redistribution in executable form of any 673446Smrj * substantial portion of the Covered Code or modification must reproduce the 683446Smrj * above Copyright Notice, and the following Disclaimer and Export Compliance 693446Smrj * provision in the documentation and/or other materials provided with the 703446Smrj * distribution. 713446Smrj * 723446Smrj * 3.4. Intel retains all right, title, and interest in and to the Original 733446Smrj * Intel Code. 743446Smrj * 753446Smrj * 3.5. Neither the name Intel nor any other trademark owned or controlled by 763446Smrj * Intel shall be used in advertising or otherwise to promote the sale, use or 773446Smrj * other dealings in products derived from or relating to the Covered Code 783446Smrj * without prior written authorization from Intel. 793446Smrj * 803446Smrj * 4. Disclaimer and Export Compliance 813446Smrj * 823446Smrj * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 833446Smrj * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 843446Smrj * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 853446Smrj * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 863446Smrj * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 873446Smrj * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 883446Smrj * PARTICULAR PURPOSE. 893446Smrj * 903446Smrj * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 913446Smrj * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 923446Smrj * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 933446Smrj * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 943446Smrj * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 953446Smrj * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 963446Smrj * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 973446Smrj * LIMITED REMEDY. 983446Smrj * 993446Smrj * 4.3. Licensee shall not export, either directly or indirectly, any of this 1003446Smrj * software or system incorporating such software without first obtaining any 1013446Smrj * required license or other approval from the U. S. Department of Commerce or 1023446Smrj * any other agency or department of the United States Government. In the 1033446Smrj * event Licensee exports any such software from the United States or 1043446Smrj * re-exports any such software from a foreign destination, Licensee shall 1053446Smrj * ensure that the distribution and export/re-export of the software is in 1063446Smrj * compliance with all laws, regulations, orders, or other restrictions of the 1073446Smrj * U.S. Export Administration Regulations. Licensee agrees that neither it nor 1083446Smrj * any of its subsidiaries will export/re-export any technical data, process, 1093446Smrj * software, or service, directly or indirectly, to any country for which the 1103446Smrj * United States government or any agency thereof requires an export license, 1113446Smrj * other governmental approval, or letter of assurance, without first obtaining 1123446Smrj * such license, approval or letter. 1133446Smrj * 1143446Smrj *****************************************************************************/ 1153446Smrj 1163446Smrj 1173446Smrj #define __UTMATH_C__ 1183446Smrj 1193446Smrj #include "acpi.h" 120*9980SDana.Myers@Sun.COM #include "accommon.h" 1213446Smrj 1223446Smrj 1233446Smrj #define _COMPONENT ACPI_UTILITIES 1243446Smrj ACPI_MODULE_NAME ("utmath") 1253446Smrj 1263446Smrj /* 1273446Smrj * Support for double-precision integer divide. This code is included here 1283446Smrj * in order to support kernel environments where the double-precision math 1293446Smrj * library is not available. 1303446Smrj */ 1313446Smrj 1323446Smrj #ifndef ACPI_USE_NATIVE_DIVIDE 1333446Smrj /******************************************************************************* 1343446Smrj * 1353446Smrj * FUNCTION: AcpiUtShortDivide 1363446Smrj * 1373446Smrj * PARAMETERS: Dividend - 64-bit dividend 1383446Smrj * Divisor - 32-bit divisor 1393446Smrj * OutQuotient - Pointer to where the quotient is returned 1403446Smrj * OutRemainder - Pointer to where the remainder is returned 1413446Smrj * 1423446Smrj * RETURN: Status (Checks for divide-by-zero) 1433446Smrj * 1443446Smrj * DESCRIPTION: Perform a short (maximum 64 bits divided by 32 bits) 1453446Smrj * divide and modulo. The result is a 64-bit quotient and a 1463446Smrj * 32-bit remainder. 1473446Smrj * 1483446Smrj ******************************************************************************/ 1493446Smrj 1503446Smrj ACPI_STATUS 1513446Smrj AcpiUtShortDivide ( 1523446Smrj ACPI_INTEGER Dividend, 1533446Smrj UINT32 Divisor, 1543446Smrj ACPI_INTEGER *OutQuotient, 1553446Smrj UINT32 *OutRemainder) 1563446Smrj { 1573446Smrj UINT64_OVERLAY DividendOvl; 1583446Smrj UINT64_OVERLAY Quotient; 1593446Smrj UINT32 Remainder32; 1603446Smrj 1613446Smrj 1623446Smrj ACPI_FUNCTION_TRACE (UtShortDivide); 1633446Smrj 1643446Smrj 1653446Smrj /* Always check for a zero divisor */ 1663446Smrj 1673446Smrj if (Divisor == 0) 1683446Smrj { 1693446Smrj ACPI_ERROR ((AE_INFO, "Divide by zero")); 1703446Smrj return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO); 1713446Smrj } 1723446Smrj 1733446Smrj DividendOvl.Full = Dividend; 1743446Smrj 1753446Smrj /* 1763446Smrj * The quotient is 64 bits, the remainder is always 32 bits, 1773446Smrj * and is generated by the second divide. 1783446Smrj */ 1793446Smrj ACPI_DIV_64_BY_32 (0, DividendOvl.Part.Hi, Divisor, 1803446Smrj Quotient.Part.Hi, Remainder32); 1813446Smrj ACPI_DIV_64_BY_32 (Remainder32, DividendOvl.Part.Lo, Divisor, 1823446Smrj Quotient.Part.Lo, Remainder32); 1833446Smrj 1843446Smrj /* Return only what was requested */ 1853446Smrj 1863446Smrj if (OutQuotient) 1873446Smrj { 1883446Smrj *OutQuotient = Quotient.Full; 1893446Smrj } 1903446Smrj if (OutRemainder) 1913446Smrj { 1923446Smrj *OutRemainder = Remainder32; 1933446Smrj } 1943446Smrj 1953446Smrj return_ACPI_STATUS (AE_OK); 1963446Smrj } 1973446Smrj 1983446Smrj 1993446Smrj /******************************************************************************* 2003446Smrj * 2013446Smrj * FUNCTION: AcpiUtDivide 2023446Smrj * 2033446Smrj * PARAMETERS: InDividend - Dividend 2043446Smrj * InDivisor - Divisor 2053446Smrj * OutQuotient - Pointer to where the quotient is returned 2063446Smrj * OutRemainder - Pointer to where the remainder is returned 2073446Smrj * 2083446Smrj * RETURN: Status (Checks for divide-by-zero) 2093446Smrj * 2103446Smrj * DESCRIPTION: Perform a divide and modulo. 2113446Smrj * 2123446Smrj ******************************************************************************/ 2133446Smrj 2143446Smrj ACPI_STATUS 2153446Smrj AcpiUtDivide ( 2163446Smrj ACPI_INTEGER InDividend, 2173446Smrj ACPI_INTEGER InDivisor, 2183446Smrj ACPI_INTEGER *OutQuotient, 2193446Smrj ACPI_INTEGER *OutRemainder) 2203446Smrj { 2213446Smrj UINT64_OVERLAY Dividend; 2223446Smrj UINT64_OVERLAY Divisor; 2233446Smrj UINT64_OVERLAY Quotient; 2243446Smrj UINT64_OVERLAY Remainder; 2253446Smrj UINT64_OVERLAY NormalizedDividend; 2263446Smrj UINT64_OVERLAY NormalizedDivisor; 2273446Smrj UINT32 Partial1; 2283446Smrj UINT64_OVERLAY Partial2; 2293446Smrj UINT64_OVERLAY Partial3; 2303446Smrj 2313446Smrj 2323446Smrj ACPI_FUNCTION_TRACE (UtDivide); 2333446Smrj 2343446Smrj 2353446Smrj /* Always check for a zero divisor */ 2363446Smrj 2373446Smrj if (InDivisor == 0) 2383446Smrj { 2393446Smrj ACPI_ERROR ((AE_INFO, "Divide by zero")); 2403446Smrj return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO); 2413446Smrj } 2423446Smrj 2433446Smrj Divisor.Full = InDivisor; 2443446Smrj Dividend.Full = InDividend; 2453446Smrj if (Divisor.Part.Hi == 0) 2463446Smrj { 2473446Smrj /* 2483446Smrj * 1) Simplest case is where the divisor is 32 bits, we can 2493446Smrj * just do two divides 2503446Smrj */ 2513446Smrj Remainder.Part.Hi = 0; 2523446Smrj 2533446Smrj /* 2543446Smrj * The quotient is 64 bits, the remainder is always 32 bits, 2553446Smrj * and is generated by the second divide. 2563446Smrj */ 2573446Smrj ACPI_DIV_64_BY_32 (0, Dividend.Part.Hi, Divisor.Part.Lo, 2583446Smrj Quotient.Part.Hi, Partial1); 2593446Smrj ACPI_DIV_64_BY_32 (Partial1, Dividend.Part.Lo, Divisor.Part.Lo, 2603446Smrj Quotient.Part.Lo, Remainder.Part.Lo); 2613446Smrj } 2623446Smrj 2633446Smrj else 2643446Smrj { 2653446Smrj /* 2663446Smrj * 2) The general case where the divisor is a full 64 bits 2673446Smrj * is more difficult 2683446Smrj */ 2693446Smrj Quotient.Part.Hi = 0; 2703446Smrj NormalizedDividend = Dividend; 2713446Smrj NormalizedDivisor = Divisor; 2723446Smrj 2733446Smrj /* Normalize the operands (shift until the divisor is < 32 bits) */ 2743446Smrj 2753446Smrj do 2763446Smrj { 2773446Smrj ACPI_SHIFT_RIGHT_64 (NormalizedDivisor.Part.Hi, 2783446Smrj NormalizedDivisor.Part.Lo); 2793446Smrj ACPI_SHIFT_RIGHT_64 (NormalizedDividend.Part.Hi, 2803446Smrj NormalizedDividend.Part.Lo); 2813446Smrj 2823446Smrj } while (NormalizedDivisor.Part.Hi != 0); 2833446Smrj 2843446Smrj /* Partial divide */ 2853446Smrj 2863446Smrj ACPI_DIV_64_BY_32 (NormalizedDividend.Part.Hi, 2873446Smrj NormalizedDividend.Part.Lo, 2883446Smrj NormalizedDivisor.Part.Lo, 2893446Smrj Quotient.Part.Lo, Partial1); 2903446Smrj 2913446Smrj /* 2923446Smrj * The quotient is always 32 bits, and simply requires adjustment. 2933446Smrj * The 64-bit remainder must be generated. 2943446Smrj */ 2953446Smrj Partial1 = Quotient.Part.Lo * Divisor.Part.Hi; 2963446Smrj Partial2.Full = (ACPI_INTEGER) Quotient.Part.Lo * Divisor.Part.Lo; 2973446Smrj Partial3.Full = (ACPI_INTEGER) Partial2.Part.Hi + Partial1; 2983446Smrj 2993446Smrj Remainder.Part.Hi = Partial3.Part.Lo; 3003446Smrj Remainder.Part.Lo = Partial2.Part.Lo; 3013446Smrj 3023446Smrj if (Partial3.Part.Hi == 0) 3033446Smrj { 3043446Smrj if (Partial3.Part.Lo >= Dividend.Part.Hi) 3053446Smrj { 3063446Smrj if (Partial3.Part.Lo == Dividend.Part.Hi) 3073446Smrj { 3083446Smrj if (Partial2.Part.Lo > Dividend.Part.Lo) 3093446Smrj { 3103446Smrj Quotient.Part.Lo--; 3113446Smrj Remainder.Full -= Divisor.Full; 3123446Smrj } 3133446Smrj } 3143446Smrj else 3153446Smrj { 3163446Smrj Quotient.Part.Lo--; 3173446Smrj Remainder.Full -= Divisor.Full; 3183446Smrj } 3193446Smrj } 3203446Smrj 3213446Smrj Remainder.Full = Remainder.Full - Dividend.Full; 3223446Smrj Remainder.Part.Hi = (UINT32) -((INT32) Remainder.Part.Hi); 3233446Smrj Remainder.Part.Lo = (UINT32) -((INT32) Remainder.Part.Lo); 3243446Smrj 3253446Smrj if (Remainder.Part.Lo) 3263446Smrj { 3273446Smrj Remainder.Part.Hi--; 3283446Smrj } 3293446Smrj } 3303446Smrj } 3313446Smrj 3323446Smrj /* Return only what was requested */ 3333446Smrj 3343446Smrj if (OutQuotient) 3353446Smrj { 3363446Smrj *OutQuotient = Quotient.Full; 3373446Smrj } 3383446Smrj if (OutRemainder) 3393446Smrj { 3403446Smrj *OutRemainder = Remainder.Full; 3413446Smrj } 3423446Smrj 3433446Smrj return_ACPI_STATUS (AE_OK); 3443446Smrj } 3453446Smrj 3463446Smrj #else 3473446Smrj 3483446Smrj /******************************************************************************* 3493446Smrj * 3503446Smrj * FUNCTION: AcpiUtShortDivide, AcpiUtDivide 3513446Smrj * 3523446Smrj * PARAMETERS: See function headers above 3533446Smrj * 3543446Smrj * DESCRIPTION: Native versions of the UtDivide functions. Use these if either 3553446Smrj * 1) The target is a 64-bit platform and therefore 64-bit 3563446Smrj * integer math is supported directly by the machine. 3573446Smrj * 2) The target is a 32-bit or 16-bit platform, and the 3583446Smrj * double-precision integer math library is available to 3593446Smrj * perform the divide. 3603446Smrj * 3613446Smrj ******************************************************************************/ 3623446Smrj 3633446Smrj ACPI_STATUS 3643446Smrj AcpiUtShortDivide ( 3653446Smrj ACPI_INTEGER InDividend, 3663446Smrj UINT32 Divisor, 3673446Smrj ACPI_INTEGER *OutQuotient, 3683446Smrj UINT32 *OutRemainder) 3693446Smrj { 3703446Smrj 3713446Smrj ACPI_FUNCTION_TRACE (UtShortDivide); 3723446Smrj 3733446Smrj 3743446Smrj /* Always check for a zero divisor */ 3753446Smrj 3763446Smrj if (Divisor == 0) 3773446Smrj { 3783446Smrj ACPI_ERROR ((AE_INFO, "Divide by zero")); 3793446Smrj return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO); 3803446Smrj } 3813446Smrj 3823446Smrj /* Return only what was requested */ 3833446Smrj 3843446Smrj if (OutQuotient) 3853446Smrj { 3863446Smrj *OutQuotient = InDividend / Divisor; 3873446Smrj } 3883446Smrj if (OutRemainder) 3893446Smrj { 3907851SDana.Myers@Sun.COM *OutRemainder = (UINT32) (InDividend % Divisor); 3913446Smrj } 3923446Smrj 3933446Smrj return_ACPI_STATUS (AE_OK); 3943446Smrj } 3953446Smrj 3963446Smrj ACPI_STATUS 3973446Smrj AcpiUtDivide ( 3983446Smrj ACPI_INTEGER InDividend, 3993446Smrj ACPI_INTEGER InDivisor, 4003446Smrj ACPI_INTEGER *OutQuotient, 4013446Smrj ACPI_INTEGER *OutRemainder) 4023446Smrj { 4033446Smrj ACPI_FUNCTION_TRACE (UtDivide); 4043446Smrj 4053446Smrj 4063446Smrj /* Always check for a zero divisor */ 4073446Smrj 4083446Smrj if (InDivisor == 0) 4093446Smrj { 4103446Smrj ACPI_ERROR ((AE_INFO, "Divide by zero")); 4113446Smrj return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO); 4123446Smrj } 4133446Smrj 4143446Smrj 4153446Smrj /* Return only what was requested */ 4163446Smrj 4173446Smrj if (OutQuotient) 4183446Smrj { 4193446Smrj *OutQuotient = InDividend / InDivisor; 4203446Smrj } 4213446Smrj if (OutRemainder) 4223446Smrj { 4233446Smrj *OutRemainder = InDividend % InDivisor; 4243446Smrj } 4253446Smrj 4263446Smrj return_ACPI_STATUS (AE_OK); 4273446Smrj } 4283446Smrj 4293446Smrj #endif 4303446Smrj 4313446Smrj 432