patch-2.4.14 linux/drivers/acpi/utilities/utmath.c

• Lines: 315
• Date: Wed Oct 24 14:06:22 2001
• Orig file: v2.4.13/linux/drivers/acpi/utilities/utmath.c
• Orig date: Wed Dec 31 16:00:00 1969

diff -u --recursive --new-file v2.4.13/linux/drivers/acpi/utilities/utmath.c linux/drivers/acpi/utilities/utmath.c
@@ -0,0 +1,314 @@
+/*******************************************************************************
+ *
+ * Module Name: utmath - Integer math support routines
+ *              $Revision: 7 $
+ *
+ ******************************************************************************/
+
+/*
+ *  Copyright (C) 2000, 2001 R. Byron Moore
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+#include "acpi.h"
+
+
+#define _COMPONENT          ACPI_UTILITIES
+	 MODULE_NAME         ("utmath")
+
+/*
+ * Support for double-precision integer divide.  This code is included here
+ * in order to support kernel environments where the double-precision math
+ * library is not available.
+ */
+
+#ifndef ACPI_USE_NATIVE_DIVIDE
+/*******************************************************************************
+ *
+ * FUNCTION:    Acpi_ut_short_divide
+ *
+ * PARAMETERS:  In_dividend         - Pointer to the dividend
+ *              Divisor             - 32-bit divisor
+ *              Out_quotient        - Pointer to where the quotient is returned
+ *              Out_remainder       - Pointer to where the remainder is returned
+ *
+ * RETURN:      Status (Checks for divide-by-zero)
+ *
+ * DESCRIPTION: Perform a short (maximum 64 bits divided by 32 bits)
+ *              divide and modulo.  The result is a 64-bit quotient and a
+ *              32-bit remainder.
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ut_short_divide (
+	acpi_integer            *in_dividend,
+	u32                     divisor,
+	acpi_integer            *out_quotient,
+	u32                     *out_remainder)
+{
+	uint64_overlay          dividend;
+	uint64_overlay          quotient;
+	u32                     remainder32;
+
+
+	FUNCTION_TRACE ("Ut_short_divide");
+
+	dividend.full = *in_dividend;
+
+	/* Always check for a zero divisor */
+
+	if (divisor == 0) {
+		REPORT_ERROR (("Acpi_ut_short_divide: Divide by zero\n"));
+		return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
+	}
+
+	/*
+	 * The quotient is 64 bits, the remainder is always 32 bits,
+	 * and is generated by the second divide.
+	 */
+	ACPI_DIV_64_BY_32 (0, dividend.part.hi, divisor,
+			  quotient.part.hi, remainder32);
+	ACPI_DIV_64_BY_32 (remainder32, dividend.part.lo,  divisor,
+			  quotient.part.lo, remainder32);
+
+	/* Return only what was requested */
+
+	if (out_quotient) {
+		*out_quotient = quotient.full;
+	}
+	if (out_remainder) {
+		*out_remainder = remainder32;
+	}
+
+	return_ACPI_STATUS (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    Acpi_ut_divide
+ *
+ * PARAMETERS:  In_dividend         - Pointer to the dividend
+ *              In_divisor          - Pointer to the divisor
+ *              Out_quotient        - Pointer to where the quotient is returned
+ *              Out_remainder       - Pointer to where the remainder is returned
+ *
+ * RETURN:      Status (Checks for divide-by-zero)
+ *
+ * DESCRIPTION: Perform a divide and modulo.
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ut_divide (
+	acpi_integer            *in_dividend,
+	acpi_integer            *in_divisor,
+	acpi_integer            *out_quotient,
+	acpi_integer            *out_remainder)
+{
+	uint64_overlay          dividend;
+	uint64_overlay          divisor;
+	uint64_overlay          quotient;
+	uint64_overlay          remainder;
+	uint64_overlay          normalized_dividend;
+	uint64_overlay          normalized_divisor;
+	u32                     partial1;
+	uint64_overlay          partial2;
+	uint64_overlay          partial3;
+
+
+	FUNCTION_TRACE ("Ut_divide");
+
+
+	/* Always check for a zero divisor */
+
+	if (*in_divisor == 0) {
+		REPORT_ERROR (("Acpi_ut_divide: Divide by zero\n"));
+		return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
+	}
+
+	divisor.full  = *in_divisor;
+	dividend.full = *in_dividend;
+	if (divisor.part.hi == 0) {
+		/*
+		 * 1) Simplest case is where the divisor is 32 bits, we can
+		 * just do two divides
+		 */
+		remainder.part.hi = 0;
+
+		/*
+		 * The quotient is 64 bits, the remainder is always 32 bits,
+		 * and is generated by the second divide.
+		 */
+		ACPI_DIV_64_BY_32 (0, dividend.part.hi, divisor.part.lo,
+				  quotient.part.hi, partial1);
+		ACPI_DIV_64_BY_32 (partial1, dividend.part.lo, divisor.part.lo,
+				  quotient.part.lo, remainder.part.lo);
+	}
+
+	else {
+		/*
+		 * 2) The general case where the divisor is a full 64 bits
+		 * is more difficult
+		 */
+		quotient.part.hi   = 0;
+		normalized_dividend = dividend;
+		normalized_divisor = divisor;
+
+		/* Normalize the operands (shift until the divisor is < 32 bits) */
+
+		do {
+			ACPI_SHIFT_RIGHT_64 (normalized_divisor.part.hi,
+					 normalized_divisor.part.lo);
+			ACPI_SHIFT_RIGHT_64 (normalized_dividend.part.hi,
+					 normalized_dividend.part.lo);
+
+		} while (normalized_divisor.part.hi != 0);
+
+		/* Partial divide */
+
+		ACPI_DIV_64_BY_32 (normalized_dividend.part.hi,
+				  normalized_dividend.part.lo,
+				  normalized_divisor.part.lo,
+				  quotient.part.lo, partial1);
+
+		/*
+		 * The quotient is always 32 bits, and simply requires adjustment.
+		 * The 64-bit remainder must be generated.
+		 */
+		partial1      = quotient.part.lo * divisor.part.hi;
+		partial2.full = (acpi_integer) quotient.part.lo * divisor.part.lo;
+		partial3.full = partial2.part.hi + partial1;
+
+		remainder.part.hi = partial3.part.lo;
+		remainder.part.lo = partial2.part.lo;
+
+		if (partial3.part.hi == 0) {
+			if (partial3.part.lo >= dividend.part.hi) {
+				if (partial3.part.lo == dividend.part.hi) {
+					if (partial2.part.lo > dividend.part.lo) {
+						quotient.part.lo--;
+						remainder.full -= divisor.full;
+					}
+				}
+				else {
+					quotient.part.lo--;
+					remainder.full -= divisor.full;
+				}
+			}
+
+			remainder.full    = remainder.full - dividend.full;
+			remainder.part.hi = -((s32) remainder.part.hi);
+			remainder.part.lo = -((s32) remainder.part.lo);
+
+			if (remainder.part.lo) {
+				remainder.part.hi--;
+			}
+		}
+	}
+
+	/* Return only what was requested */
+
+	if (out_quotient) {
+		*out_quotient = quotient.full;
+	}
+	if (out_remainder) {
+		*out_remainder = remainder.full;
+	}
+
+	return_ACPI_STATUS (AE_OK);
+}
+
+#else
+
+/*******************************************************************************
+ *
+ * FUNCTION:    Acpi_ut_short_divide, Acpi_ut_divide
+ *
+ * DESCRIPTION: Native versions of the Ut_divide functions. Use these if either
+ *              1) The target is a 64-bit platform and therefore 64-bit
+ *                 integer math is supported directly by the machine.
+ *              2) The target is a 32-bit or 16-bit platform, and the
+ *                 double-precision integer math library is available to
+ *                 perform the divide.
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ut_short_divide (
+	acpi_integer            *in_dividend,
+	u32                     divisor,
+	acpi_integer            *out_quotient,
+	u32                     *out_remainder)
+{
+
+	FUNCTION_TRACE ("Ut_short_divide");
+
+
+	/* Always check for a zero divisor */
+
+	if (divisor == 0) {
+		REPORT_ERROR (("Acpi_ut_short_divide: Divide by zero\n"));
+		return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
+	}
+
+	/* Return only what was requested */
+
+	if (out_quotient) {
+		*out_quotient = *in_dividend / divisor;
+	}
+	if (out_remainder) {
+		*out_remainder = (u32) *in_dividend % divisor;
+	}
+
+	return_ACPI_STATUS (AE_OK);
+}
+
+acpi_status
+acpi_ut_divide (
+	acpi_integer            *in_dividend,
+	acpi_integer            *in_divisor,
+	acpi_integer            *out_quotient,
+	acpi_integer            *out_remainder)
+{
+	FUNCTION_TRACE ("Ut_divide");
+
+
+	/* Always check for a zero divisor */
+
+	if (*in_divisor == 0) {
+		REPORT_ERROR (("Acpi_ut_divide: Divide by zero\n"));
+		return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
+	}
+
+
+	/* Return only what was requested */
+
+	if (out_quotient) {
+		*out_quotient = *in_dividend / *in_divisor;
+	}
+	if (out_remainder) {
+		*out_remainder = *in_dividend % *in_divisor;
+	}
+
+	return_ACPI_STATUS (AE_OK);
+}
+
+#endif
+
+