Merge branch 'pm-sleep'
authorRafael J. Wysocki <rafael.j.wysocki@intel.com>
Sat, 5 Jan 2013 23:36:17 +0000 (00:36 +0100)
committerRafael J. Wysocki <rafael.j.wysocki@intel.com>
Sat, 5 Jan 2013 23:36:17 +0000 (00:36 +0100)
* pm-sleep:
  PM: Move disabling/enabling runtime PM to late suspend/early resume

20 files changed:
drivers/acpi/acpi_memhotplug.c
drivers/acpi/acpica/Makefile
drivers/acpi/acpica/utclib.c [deleted file]
drivers/acpi/apei/erst-dbg.c
drivers/acpi/device_pm.c
drivers/acpi/glue.c
drivers/acpi/power.c
drivers/acpi/scan.c
drivers/base/power/qos.c
drivers/cpufreq/Kconfig
drivers/cpufreq/Makefile
drivers/cpufreq/cpufreq_stats.c
drivers/cpufreq/longhaul.c
drivers/cpuidle/coupled.c
drivers/cpuidle/cpuidle.c
drivers/cpuidle/driver.c
drivers/cpuidle/governors/menu.c
drivers/idle/intel_idle.c
drivers/pnp/interface.c
drivers/pnp/manager.c

index eb30e5ab4cab6810197aa12c36d6421962a6b3f6..b679bf8478f7a4bd3483127853cceb75185f97aa 100644 (file)
@@ -226,16 +226,6 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
        struct acpi_memory_info *info;
        int node;
 
-
-       /* Get the range from the _CRS */
-       result = acpi_memory_get_device_resources(mem_device);
-       if (result) {
-               dev_err(&mem_device->device->dev,
-                       "get_device_resources failed\n");
-               mem_device->state = MEMORY_INVALID_STATE;
-               return result;
-       }
-
        node = acpi_get_node(mem_device->device->handle);
        /*
         * Tell the VM there is more memory here...
@@ -342,14 +332,6 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
                        break;
                }
 
-               if (acpi_memory_check_device(mem_device))
-                       break;
-
-               if (acpi_memory_enable_device(mem_device)) {
-                       acpi_handle_err(handle,"Cannot enable memory device\n");
-                       break;
-               }
-
                ost_code = ACPI_OST_SC_SUCCESS;
                break;
 
index c8bc24bd1f720580b6e80ce4225277c781576b23..bc7a03ded064520fd88d64a4d335bf1d0a6813e8 100644 (file)
@@ -162,5 +162,5 @@ acpi-y +=           \
        utxferror.o     \
        utxfmutex.o
 
-acpi-$(ACPI_FUTURE_USAGE) += uttrack.o utcache.o utclib.o
+acpi-$(ACPI_FUTURE_USAGE) += uttrack.o utcache.o
 
diff --git a/drivers/acpi/acpica/utclib.c b/drivers/acpi/acpica/utclib.c
deleted file mode 100644 (file)
index 19ea475..0000000
+++ /dev/null
@@ -1,749 +0,0 @@
-/******************************************************************************
- *
- * Module Name: cmclib - Local implementation of C library functions
- *
- *****************************************************************************/
-
-/*
- * Copyright (C) 2000 - 2012, Intel Corp.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions, and the following disclaimer,
- *    without modification.
- * 2. Redistributions in binary form must reproduce at minimum a disclaimer
- *    substantially similar to the "NO WARRANTY" disclaimer below
- *    ("Disclaimer") and any redistribution must be conditioned upon
- *    including a substantially similar Disclaimer requirement for further
- *    binary redistribution.
- * 3. Neither the names of the above-listed copyright holders nor the names
- *    of any contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * Alternatively, this software may be distributed under the terms of the
- * GNU General Public License ("GPL") version 2 as published by the Free
- * Software Foundation.
- *
- * NO WARRANTY
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
- * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGES.
- */
-
-#include <acpi/acpi.h>
-#include "accommon.h"
-
-/*
- * These implementations of standard C Library routines can optionally be
- * used if a C library is not available. In general, they are less efficient
- * than an inline or assembly implementation
- */
-
-#define _COMPONENT          ACPI_UTILITIES
-ACPI_MODULE_NAME("cmclib")
-
-#ifndef ACPI_USE_SYSTEM_CLIBRARY
-#define NEGATIVE    1
-#define POSITIVE    0
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_memcmp (memcmp)
- *
- * PARAMETERS:  buffer1         - First Buffer
- *              buffer2         - Second Buffer
- *              count           - Maximum # of bytes to compare
- *
- * RETURN:      Index where Buffers mismatched, or 0 if Buffers matched
- *
- * DESCRIPTION: Compare two Buffers, with a maximum length
- *
- ******************************************************************************/
-int acpi_ut_memcmp(const char *buffer1, const char *buffer2, acpi_size count)
-{
-
-       return ((count == ACPI_SIZE_MAX) ? 0 : ((unsigned char)*buffer1 -
-                                               (unsigned char)*buffer2));
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_memcpy (memcpy)
- *
- * PARAMETERS:  dest        - Target of the copy
- *              src         - Source buffer to copy
- *              count       - Number of bytes to copy
- *
- * RETURN:      Dest
- *
- * DESCRIPTION: Copy arbitrary bytes of memory
- *
- ******************************************************************************/
-
-void *acpi_ut_memcpy(void *dest, const void *src, acpi_size count)
-{
-       char *new = (char *)dest;
-       char *old = (char *)src;
-
-       while (count) {
-               *new = *old;
-               new++;
-               old++;
-               count--;
-       }
-
-       return (dest);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_memset (memset)
- *
- * PARAMETERS:  dest        - Buffer to set
- *              value       - Value to set each byte of memory
- *              count       - Number of bytes to set
- *
- * RETURN:      Dest
- *
- * DESCRIPTION: Initialize a buffer to a known value.
- *
- ******************************************************************************/
-
-void *acpi_ut_memset(void *dest, u8 value, acpi_size count)
-{
-       char *new = (char *)dest;
-
-       while (count) {
-               *new = (char)value;
-               new++;
-               count--;
-       }
-
-       return (dest);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_strlen (strlen)
- *
- * PARAMETERS:  string              - Null terminated string
- *
- * RETURN:      Length
- *
- * DESCRIPTION: Returns the length of the input string
- *
- ******************************************************************************/
-
-acpi_size acpi_ut_strlen(const char *string)
-{
-       u32 length = 0;
-
-       /* Count the string until a null is encountered */
-
-       while (*string) {
-               length++;
-               string++;
-       }
-
-       return (length);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_strcpy (strcpy)
- *
- * PARAMETERS:  dst_string      - Target of the copy
- *              src_string      - The source string to copy
- *
- * RETURN:      dst_string
- *
- * DESCRIPTION: Copy a null terminated string
- *
- ******************************************************************************/
-
-char *acpi_ut_strcpy(char *dst_string, const char *src_string)
-{
-       char *string = dst_string;
-
-       /* Move bytes brute force */
-
-       while (*src_string) {
-               *string = *src_string;
-
-               string++;
-               src_string++;
-       }
-
-       /* Null terminate */
-
-       *string = 0;
-       return (dst_string);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_strncpy (strncpy)
- *
- * PARAMETERS:  dst_string      - Target of the copy
- *              src_string      - The source string to copy
- *              count           - Maximum # of bytes to copy
- *
- * RETURN:      dst_string
- *
- * DESCRIPTION: Copy a null terminated string, with a maximum length
- *
- ******************************************************************************/
-
-char *acpi_ut_strncpy(char *dst_string, const char *src_string, acpi_size count)
-{
-       char *string = dst_string;
-
-       /* Copy the string */
-
-       for (string = dst_string;
-            count && (count--, (*string++ = *src_string++));) {;
-       }
-
-       /* Pad with nulls if necessary */
-
-       while (count--) {
-               *string = 0;
-               string++;
-       }
-
-       /* Return original pointer */
-
-       return (dst_string);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_strcmp (strcmp)
- *
- * PARAMETERS:  string1         - First string
- *              string2         - Second string
- *
- * RETURN:      Index where strings mismatched, or 0 if strings matched
- *
- * DESCRIPTION: Compare two null terminated strings
- *
- ******************************************************************************/
-
-int acpi_ut_strcmp(const char *string1, const char *string2)
-{
-
-       for (; (*string1 == *string2); string2++) {
-               if (!*string1++) {
-                       return (0);
-               }
-       }
-
-       return ((unsigned char)*string1 - (unsigned char)*string2);
-}
-
-#ifdef ACPI_FUTURE_IMPLEMENTATION
-/* Not used at this time */
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_strchr (strchr)
- *
- * PARAMETERS:  string          - Search string
- *              ch              - character to search for
- *
- * RETURN:      Ptr to char or NULL if not found
- *
- * DESCRIPTION: Search a string for a character
- *
- ******************************************************************************/
-
-char *acpi_ut_strchr(const char *string, int ch)
-{
-
-       for (; (*string); string++) {
-               if ((*string) == (char)ch) {
-                       return ((char *)string);
-               }
-       }
-
-       return (NULL);
-}
-#endif
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_strncmp (strncmp)
- *
- * PARAMETERS:  string1         - First string
- *              string2         - Second string
- *              count           - Maximum # of bytes to compare
- *
- * RETURN:      Index where strings mismatched, or 0 if strings matched
- *
- * DESCRIPTION: Compare two null terminated strings, with a maximum length
- *
- ******************************************************************************/
-
-int acpi_ut_strncmp(const char *string1, const char *string2, acpi_size count)
-{
-
-       for (; count-- && (*string1 == *string2); string2++) {
-               if (!*string1++) {
-                       return (0);
-               }
-       }
-
-       return ((count == ACPI_SIZE_MAX) ? 0 : ((unsigned char)*string1 -
-                                               (unsigned char)*string2));
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_strcat (Strcat)
- *
- * PARAMETERS:  dst_string      - Target of the copy
- *              src_string      - The source string to copy
- *
- * RETURN:      dst_string
- *
- * DESCRIPTION: Append a null terminated string to a null terminated string
- *
- ******************************************************************************/
-
-char *acpi_ut_strcat(char *dst_string, const char *src_string)
-{
-       char *string;
-
-       /* Find end of the destination string */
-
-       for (string = dst_string; *string++;) {;
-       }
-
-       /* Concatenate the string */
-
-       for (--string; (*string++ = *src_string++);) {;
-       }
-
-       return (dst_string);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_strncat (strncat)
- *
- * PARAMETERS:  dst_string      - Target of the copy
- *              src_string      - The source string to copy
- *              count           - Maximum # of bytes to copy
- *
- * RETURN:      dst_string
- *
- * DESCRIPTION: Append a null terminated string to a null terminated string,
- *              with a maximum count.
- *
- ******************************************************************************/
-
-char *acpi_ut_strncat(char *dst_string, const char *src_string, acpi_size count)
-{
-       char *string;
-
-       if (count) {
-
-               /* Find end of the destination string */
-
-               for (string = dst_string; *string++;) {;
-               }
-
-               /* Concatenate the string */
-
-               for (--string; (*string++ = *src_string++) && --count;) {;
-               }
-
-               /* Null terminate if necessary */
-
-               if (!count) {
-                       *string = 0;
-               }
-       }
-
-       return (dst_string);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_strstr (strstr)
- *
- * PARAMETERS:  string1         - Target string
- *              string2         - Substring to search for
- *
- * RETURN:      Where substring match starts, Null if no match found
- *
- * DESCRIPTION: Checks if String2 occurs in String1. This is not really a
- *              full implementation of strstr, only sufficient for command
- *              matching
- *
- ******************************************************************************/
-
-char *acpi_ut_strstr(char *string1, char *string2)
-{
-       char *string;
-
-       if (acpi_ut_strlen(string2) > acpi_ut_strlen(string1)) {
-               return (NULL);
-       }
-
-       /* Walk entire string, comparing the letters */
-
-       for (string = string1; *string2;) {
-               if (*string2 != *string) {
-                       return (NULL);
-               }
-
-               string2++;
-               string++;
-       }
-
-       return (string1);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_strtoul (strtoul)
- *
- * PARAMETERS:  string          - Null terminated string
- *              terminater      - Where a pointer to the terminating byte is
- *                                returned
- *              base            - Radix of the string
- *
- * RETURN:      Converted value
- *
- * DESCRIPTION: Convert a string into a 32-bit unsigned value.
- *              Note: use acpi_ut_strtoul64 for 64-bit integers.
- *
- ******************************************************************************/
-
-u32 acpi_ut_strtoul(const char *string, char **terminator, u32 base)
-{
-       u32 converted = 0;
-       u32 index;
-       u32 sign;
-       const char *string_start;
-       u32 return_value = 0;
-       acpi_status status = AE_OK;
-
-       /*
-        * Save the value of the pointer to the buffer's first
-        * character, save the current errno value, and then
-        * skip over any white space in the buffer:
-        */
-       string_start = string;
-       while (ACPI_IS_SPACE(*string) || *string == '\t') {
-               ++string;
-       }
-
-       /*
-        * The buffer may contain an optional plus or minus sign.
-        * If it does, then skip over it but remember what is was:
-        */
-       if (*string == '-') {
-               sign = NEGATIVE;
-               ++string;
-       } else if (*string == '+') {
-               ++string;
-               sign = POSITIVE;
-       } else {
-               sign = POSITIVE;
-       }
-
-       /*
-        * If the input parameter Base is zero, then we need to
-        * determine if it is octal, decimal, or hexadecimal:
-        */
-       if (base == 0) {
-               if (*string == '0') {
-                       if (acpi_ut_to_lower(*(++string)) == 'x') {
-                               base = 16;
-                               ++string;
-                       } else {
-                               base = 8;
-                       }
-               } else {
-                       base = 10;
-               }
-       } else if (base < 2 || base > 36) {
-               /*
-                * The specified Base parameter is not in the domain of
-                * this function:
-                */
-               goto done;
-       }
-
-       /*
-        * For octal and hexadecimal bases, skip over the leading
-        * 0 or 0x, if they are present.
-        */
-       if (base == 8 && *string == '0') {
-               string++;
-       }
-
-       if (base == 16 &&
-           *string == '0' && acpi_ut_to_lower(*(++string)) == 'x') {
-               string++;
-       }
-
-       /*
-        * Main loop: convert the string to an unsigned long:
-        */
-       while (*string) {
-               if (ACPI_IS_DIGIT(*string)) {
-                       index = (u32)((u8)*string - '0');
-               } else {
-                       index = (u32)acpi_ut_to_upper(*string);
-                       if (ACPI_IS_UPPER(index)) {
-                               index = index - 'A' + 10;
-                       } else {
-                               goto done;
-                       }
-               }
-
-               if (index >= base) {
-                       goto done;
-               }
-
-               /*
-                * Check to see if value is out of range:
-                */
-
-               if (return_value > ((ACPI_UINT32_MAX - (u32)index) / (u32)base)) {
-                       status = AE_ERROR;
-                       return_value = 0;       /* reset */
-               } else {
-                       return_value *= base;
-                       return_value += index;
-                       converted = 1;
-               }
-
-               ++string;
-       }
-
-      done:
-       /*
-        * If appropriate, update the caller's pointer to the next
-        * unconverted character in the buffer.
-        */
-       if (terminator) {
-               if (converted == 0 && return_value == 0 && string != NULL) {
-                       *terminator = (char *)string_start;
-               } else {
-                       *terminator = (char *)string;
-               }
-       }
-
-       if (status == AE_ERROR) {
-               return_value = ACPI_UINT32_MAX;
-       }
-
-       /*
-        * If a minus sign was present, then "the conversion is negated":
-        */
-       if (sign == NEGATIVE) {
-               return_value = (ACPI_UINT32_MAX - return_value) + 1;
-       }
-
-       return (return_value);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_to_upper (TOUPPER)
- *
- * PARAMETERS:  c           - Character to convert
- *
- * RETURN:      Converted character as an int
- *
- * DESCRIPTION: Convert character to uppercase
- *
- ******************************************************************************/
-
-int acpi_ut_to_upper(int c)
-{
-
-       return (ACPI_IS_LOWER(c) ? ((c) - 0x20) : (c));
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_to_lower (TOLOWER)
- *
- * PARAMETERS:  c           - Character to convert
- *
- * RETURN:      Converted character as an int
- *
- * DESCRIPTION: Convert character to lowercase
- *
- ******************************************************************************/
-
-int acpi_ut_to_lower(int c)
-{
-
-       return (ACPI_IS_UPPER(c) ? ((c) + 0x20) : (c));
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    is* functions
- *
- * DESCRIPTION: is* functions use the ctype table below
- *
- ******************************************************************************/
-
-const u8 _acpi_ctype[257] = {
-       _ACPI_CN,               /* 0x00     0 NUL */
-       _ACPI_CN,               /* 0x01     1 SOH */
-       _ACPI_CN,               /* 0x02     2 STX */
-       _ACPI_CN,               /* 0x03     3 ETX */
-       _ACPI_CN,               /* 0x04     4 EOT */
-       _ACPI_CN,               /* 0x05     5 ENQ */
-       _ACPI_CN,               /* 0x06     6 ACK */
-       _ACPI_CN,               /* 0x07     7 BEL */
-       _ACPI_CN,               /* 0x08     8 BS  */
-       _ACPI_CN | _ACPI_SP,    /* 0x09     9 TAB */
-       _ACPI_CN | _ACPI_SP,    /* 0x0A    10 LF  */
-       _ACPI_CN | _ACPI_SP,    /* 0x0B    11 VT  */
-       _ACPI_CN | _ACPI_SP,    /* 0x0C    12 FF  */
-       _ACPI_CN | _ACPI_SP,    /* 0x0D    13 CR  */
-       _ACPI_CN,               /* 0x0E    14 SO  */
-       _ACPI_CN,               /* 0x0F    15 SI  */
-       _ACPI_CN,               /* 0x10    16 DLE */
-       _ACPI_CN,               /* 0x11    17 DC1 */
-       _ACPI_CN,               /* 0x12    18 DC2 */
-       _ACPI_CN,               /* 0x13    19 DC3 */
-       _ACPI_CN,               /* 0x14    20 DC4 */
-       _ACPI_CN,               /* 0x15    21 NAK */
-       _ACPI_CN,               /* 0x16    22 SYN */
-       _ACPI_CN,               /* 0x17    23 ETB */
-       _ACPI_CN,               /* 0x18    24 CAN */
-       _ACPI_CN,               /* 0x19    25 EM  */
-       _ACPI_CN,               /* 0x1A    26 SUB */
-       _ACPI_CN,               /* 0x1B    27 ESC */
-       _ACPI_CN,               /* 0x1C    28 FS  */
-       _ACPI_CN,               /* 0x1D    29 GS  */
-       _ACPI_CN,               /* 0x1E    30 RS  */
-       _ACPI_CN,               /* 0x1F    31 US  */
-       _ACPI_XS | _ACPI_SP,    /* 0x20    32 ' ' */
-       _ACPI_PU,               /* 0x21    33 '!' */
-       _ACPI_PU,               /* 0x22    34 '"' */
-       _ACPI_PU,               /* 0x23    35 '#' */
-       _ACPI_PU,               /* 0x24    36 '$' */
-       _ACPI_PU,               /* 0x25    37 '%' */
-       _ACPI_PU,               /* 0x26    38 '&' */
-       _ACPI_PU,               /* 0x27    39 ''' */
-       _ACPI_PU,               /* 0x28    40 '(' */
-       _ACPI_PU,               /* 0x29    41 ')' */
-       _ACPI_PU,               /* 0x2A    42 '*' */
-       _ACPI_PU,               /* 0x2B    43 '+' */
-       _ACPI_PU,               /* 0x2C    44 ',' */
-       _ACPI_PU,               /* 0x2D    45 '-' */
-       _ACPI_PU,               /* 0x2E    46 '.' */
-       _ACPI_PU,               /* 0x2F    47 '/' */
-       _ACPI_XD | _ACPI_DI,    /* 0x30    48 '0' */
-       _ACPI_XD | _ACPI_DI,    /* 0x31    49 '1' */
-       _ACPI_XD | _ACPI_DI,    /* 0x32    50 '2' */
-       _ACPI_XD | _ACPI_DI,    /* 0x33    51 '3' */
-       _ACPI_XD | _ACPI_DI,    /* 0x34    52 '4' */
-       _ACPI_XD | _ACPI_DI,    /* 0x35    53 '5' */
-       _ACPI_XD | _ACPI_DI,    /* 0x36    54 '6' */
-       _ACPI_XD | _ACPI_DI,    /* 0x37    55 '7' */
-       _ACPI_XD | _ACPI_DI,    /* 0x38    56 '8' */
-       _ACPI_XD | _ACPI_DI,    /* 0x39    57 '9' */
-       _ACPI_PU,               /* 0x3A    58 ':' */
-       _ACPI_PU,               /* 0x3B    59 ';' */
-       _ACPI_PU,               /* 0x3C    60 '<' */
-       _ACPI_PU,               /* 0x3D    61 '=' */
-       _ACPI_PU,               /* 0x3E    62 '>' */
-       _ACPI_PU,               /* 0x3F    63 '?' */
-       _ACPI_PU,               /* 0x40    64 '@' */
-       _ACPI_XD | _ACPI_UP,    /* 0x41    65 'A' */
-       _ACPI_XD | _ACPI_UP,    /* 0x42    66 'B' */
-       _ACPI_XD | _ACPI_UP,    /* 0x43    67 'C' */
-       _ACPI_XD | _ACPI_UP,    /* 0x44    68 'D' */
-       _ACPI_XD | _ACPI_UP,    /* 0x45    69 'E' */
-       _ACPI_XD | _ACPI_UP,    /* 0x46    70 'F' */
-       _ACPI_UP,               /* 0x47    71 'G' */
-       _ACPI_UP,               /* 0x48    72 'H' */
-       _ACPI_UP,               /* 0x49    73 'I' */
-       _ACPI_UP,               /* 0x4A    74 'J' */
-       _ACPI_UP,               /* 0x4B    75 'K' */
-       _ACPI_UP,               /* 0x4C    76 'L' */
-       _ACPI_UP,               /* 0x4D    77 'M' */
-       _ACPI_UP,               /* 0x4E    78 'N' */
-       _ACPI_UP,               /* 0x4F    79 'O' */
-       _ACPI_UP,               /* 0x50    80 'P' */
-       _ACPI_UP,               /* 0x51    81 'Q' */
-       _ACPI_UP,               /* 0x52    82 'R' */
-       _ACPI_UP,               /* 0x53    83 'S' */
-       _ACPI_UP,               /* 0x54    84 'T' */
-       _ACPI_UP,               /* 0x55    85 'U' */
-       _ACPI_UP,               /* 0x56    86 'V' */
-       _ACPI_UP,               /* 0x57    87 'W' */
-       _ACPI_UP,               /* 0x58    88 'X' */
-       _ACPI_UP,               /* 0x59    89 'Y' */
-       _ACPI_UP,               /* 0x5A    90 'Z' */
-       _ACPI_PU,               /* 0x5B    91 '[' */
-       _ACPI_PU,               /* 0x5C    92 '\' */
-       _ACPI_PU,               /* 0x5D    93 ']' */
-       _ACPI_PU,               /* 0x5E    94 '^' */
-       _ACPI_PU,               /* 0x5F    95 '_' */
-       _ACPI_PU,               /* 0x60    96 '`' */
-       _ACPI_XD | _ACPI_LO,    /* 0x61    97 'a' */
-       _ACPI_XD | _ACPI_LO,    /* 0x62    98 'b' */
-       _ACPI_XD | _ACPI_LO,    /* 0x63    99 'c' */
-       _ACPI_XD | _ACPI_LO,    /* 0x64   100 'd' */
-       _ACPI_XD | _ACPI_LO,    /* 0x65   101 'e' */
-       _ACPI_XD | _ACPI_LO,    /* 0x66   102 'f' */
-       _ACPI_LO,               /* 0x67   103 'g' */
-       _ACPI_LO,               /* 0x68   104 'h' */
-       _ACPI_LO,               /* 0x69   105 'i' */
-       _ACPI_LO,               /* 0x6A   106 'j' */
-       _ACPI_LO,               /* 0x6B   107 'k' */
-       _ACPI_LO,               /* 0x6C   108 'l' */
-       _ACPI_LO,               /* 0x6D   109 'm' */
-       _ACPI_LO,               /* 0x6E   110 'n' */
-       _ACPI_LO,               /* 0x6F   111 'o' */
-       _ACPI_LO,               /* 0x70   112 'p' */
-       _ACPI_LO,               /* 0x71   113 'q' */
-       _ACPI_LO,               /* 0x72   114 'r' */
-       _ACPI_LO,               /* 0x73   115 's' */
-       _ACPI_LO,               /* 0x74   116 't' */
-       _ACPI_LO,               /* 0x75   117 'u' */
-       _ACPI_LO,               /* 0x76   118 'v' */
-       _ACPI_LO,               /* 0x77   119 'w' */
-       _ACPI_LO,               /* 0x78   120 'x' */
-       _ACPI_LO,               /* 0x79   121 'y' */
-       _ACPI_LO,               /* 0x7A   122 'z' */
-       _ACPI_PU,               /* 0x7B   123 '{' */
-       _ACPI_PU,               /* 0x7C   124 '|' */
-       _ACPI_PU,               /* 0x7D   125 '}' */
-       _ACPI_PU,               /* 0x7E   126 '~' */
-       _ACPI_CN,               /* 0x7F   127 DEL */
-
-       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x80 to 0x8F    */
-       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x90 to 0x9F    */
-       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xA0 to 0xAF    */
-       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xB0 to 0xBF    */
-       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xC0 to 0xCF    */
-       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xD0 to 0xDF    */
-       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xE0 to 0xEF    */
-       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xF0 to 0xFF    */
-       0                       /* 0x100 */
-};
-
-#endif                         /* ACPI_USE_SYSTEM_CLIBRARY */
index 903549df809bf1b02cc95df234dd7442cd3fb3ee..04ab5c9d3cedc16ac5250ee70b610829216d6117 100644 (file)
@@ -111,8 +111,17 @@ retry_next:
        if (rc)
                goto out;
        /* no more record */
-       if (id == APEI_ERST_INVALID_RECORD_ID)
+       if (id == APEI_ERST_INVALID_RECORD_ID) {
+               /*
+                * If the persistent store is empty initially, the function
+                * 'erst_read' below will return "-ENOENT" value. This causes
+                * 'retry_next' label is entered again. The returned value
+                * should be zero indicating the read operation is EOF.
+                */
+               len = 0;
+
                goto out;
+       }
 retry:
        rc = len = erst_read(id, erst_dbg_buf, erst_dbg_buf_len);
        /* The record may be cleared by others, try read next record */
index f09dc987cf17bce2ea762cdf902165cdbb7bd3d9..c6ff606c6d5bb35d51b2bff23588914f99a6ba83 100644 (file)
@@ -358,8 +358,7 @@ static struct acpi_device *acpi_dev_pm_get_node(struct device *dev)
        acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
        struct acpi_device *adev;
 
-       return handle && ACPI_SUCCESS(acpi_bus_get_device(handle, &adev)) ?
-               adev : NULL;
+       return handle && !acpi_bus_get_device(handle, &adev) ? adev : NULL;
 }
 
 /**
index 01551840d2365389ae8e0ea3c67054bc8655452f..95af6f674a6cc15b9e726d2cee7440ffa4b130fb 100644 (file)
 
 #define ACPI_GLUE_DEBUG        0
 #if ACPI_GLUE_DEBUG
-#define DBG(x...) printk(PREFIX x)
+#define DBG(fmt, ...)                                          \
+       printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__)
 #else
-#define DBG(x...) do { } while(0)
+#define DBG(fmt, ...)                                          \
+do {                                                           \
+       if (0)                                                  \
+               printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__);   \
+} while (0)
 #endif
 static LIST_HEAD(bus_type_list);
 static DECLARE_RWSEM(bus_type_sem);
index 7db61b8fa11f0337de7c8dc82e80ae1fb3cb6df8..6e7b9d5238124586ca10a000726472ff29cbc191 100644 (file)
@@ -445,11 +445,8 @@ int acpi_power_resource_register_device(struct device *dev, acpi_handle handle)
                return -ENODEV;
 
        ret = acpi_bus_get_device(handle, &acpi_dev);
-       if (ret)
-               goto no_power_resource;
-
-       if (!acpi_dev->power.flags.power_resources)
-               goto no_power_resource;
+       if (ret || !acpi_dev->power.flags.power_resources)
+               return -ENODEV;
 
        powered_device = kzalloc(sizeof(*powered_device), GFP_KERNEL);
        if (!powered_device)
@@ -471,10 +468,6 @@ int acpi_power_resource_register_device(struct device *dev, acpi_handle handle)
        }
 
        return ret;
-
-no_power_resource:
-       printk(KERN_DEBUG PREFIX "Invalid Power Resource to register!\n");
-       return -ENODEV;
 }
 EXPORT_SYMBOL_GPL(acpi_power_resource_register_device);
 
index 53502d1bbf26f1bc9b5ac46d7db7ec11caa792a7..c88be6c37c309b79b147ea683b9e177b1b8cca33 100644 (file)
@@ -1346,7 +1346,7 @@ static void acpi_device_set_id(struct acpi_device *device)
                        acpi_add_id(device, ACPI_DOCK_HID);
                else if (!acpi_ibm_smbus_match(device))
                        acpi_add_id(device, ACPI_SMBUS_IBM_HID);
-               else if (!acpi_device_hid(device) &&
+               else if (list_empty(&device->pnp.ids) &&
                         ACPI_IS_ROOT_DEVICE(device->parent)) {
                        acpi_add_id(device, ACPI_BUS_HID); /* \_SB, LNXSYBUS */
                        strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
index ff46387f5308394d913d5789c16265253b56b5f0..d21349544ce5b8131b0ca217ec5618af7beca346 100644 (file)
@@ -542,19 +542,19 @@ int dev_pm_qos_add_ancestor_request(struct device *dev,
                                    struct dev_pm_qos_request *req, s32 value)
 {
        struct device *ancestor = dev->parent;
-       int error = -ENODEV;
+       int ret = -ENODEV;
 
        while (ancestor && !ancestor->power.ignore_children)
                ancestor = ancestor->parent;
 
        if (ancestor)
-               error = dev_pm_qos_add_request(ancestor, req,
-                                              DEV_PM_QOS_LATENCY, value);
+               ret = dev_pm_qos_add_request(ancestor, req,
+                                            DEV_PM_QOS_LATENCY, value);
 
-       if (error < 0)
+       if (ret < 0)
                req->dev = NULL;
 
-       return error;
+       return ret;
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_add_ancestor_request);
 
index ea512f47b789b49c842a78388f15957fb65d62be..e0a899f25e37445491574f34e8350032d6d228ae 100644 (file)
@@ -20,6 +20,9 @@ if CPU_FREQ
 config CPU_FREQ_TABLE
        tristate
 
+config CPU_FREQ_GOV_COMMON
+       bool
+
 config CPU_FREQ_STAT
        tristate "CPU frequency translation statistics"
        select CPU_FREQ_TABLE
@@ -141,6 +144,7 @@ config CPU_FREQ_GOV_USERSPACE
 config CPU_FREQ_GOV_ONDEMAND
        tristate "'ondemand' cpufreq policy governor"
        select CPU_FREQ_TABLE
+       select CPU_FREQ_GOV_COMMON
        help
          'ondemand' - This driver adds a dynamic cpufreq policy governor.
          The governor does a periodic polling and 
@@ -159,6 +163,7 @@ config CPU_FREQ_GOV_ONDEMAND
 config CPU_FREQ_GOV_CONSERVATIVE
        tristate "'conservative' cpufreq governor"
        depends on CPU_FREQ
+       select CPU_FREQ_GOV_COMMON
        help
          'conservative' - this driver is rather similar to the 'ondemand'
          governor both in its source code and its purpose, the difference is
index 1f254ec087c1c398d3da2035d477e37d8523b969..fadc4d496e2fc55383c2f9ddf6c59b9ff2072ec3 100644 (file)
@@ -7,8 +7,9 @@ obj-$(CONFIG_CPU_FREQ_STAT)             += cpufreq_stats.o
 obj-$(CONFIG_CPU_FREQ_GOV_PERFORMANCE) += cpufreq_performance.o
 obj-$(CONFIG_CPU_FREQ_GOV_POWERSAVE)   += cpufreq_powersave.o
 obj-$(CONFIG_CPU_FREQ_GOV_USERSPACE)   += cpufreq_userspace.o
-obj-$(CONFIG_CPU_FREQ_GOV_ONDEMAND)    += cpufreq_ondemand.o cpufreq_governor.o
-obj-$(CONFIG_CPU_FREQ_GOV_CONSERVATIVE)        += cpufreq_conservative.o cpufreq_governor.o
+obj-$(CONFIG_CPU_FREQ_GOV_ONDEMAND)    += cpufreq_ondemand.o
+obj-$(CONFIG_CPU_FREQ_GOV_CONSERVATIVE)        += cpufreq_conservative.o
+obj-$(CONFIG_CPU_FREQ_GOV_COMMON)              += cpufreq_governor.o
 
 # CPUfreq cross-arch helpers
 obj-$(CONFIG_CPU_FREQ_TABLE)           += freq_table.o
index e40e508096443b683d7e3b9b2571af2a9a0d6c17..9d7732b810445f6b73318e574924b6bed6ac6829 100644 (file)
@@ -364,18 +364,21 @@ static int __init cpufreq_stats_init(void)
        if (ret)
                return ret;
 
+       register_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
+       for_each_online_cpu(cpu)
+               cpufreq_update_policy(cpu);
+
        ret = cpufreq_register_notifier(&notifier_trans_block,
                                CPUFREQ_TRANSITION_NOTIFIER);
        if (ret) {
                cpufreq_unregister_notifier(&notifier_policy_block,
                                CPUFREQ_POLICY_NOTIFIER);
+               unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
+               for_each_online_cpu(cpu)
+                       cpufreq_stats_free_table(cpu);
                return ret;
        }
 
-       register_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
-       for_each_online_cpu(cpu) {
-               cpufreq_update_policy(cpu);
-       }
        return 0;
 }
 static void __exit cpufreq_stats_exit(void)
index f1fa500ac1056e30242cfc4de6b94d267ada23d0..1180d536d1eb6cf8c2d59b4d1432a0f65be85675 100644 (file)
@@ -77,7 +77,7 @@ static unsigned int longhaul_index;
 static int scale_voltage;
 static int disable_acpi_c3;
 static int revid_errata;
-
+static int enable;
 
 /* Clock ratios multiplied by 10 */
 static int mults[32];
@@ -965,6 +965,10 @@ static int __init longhaul_init(void)
        if (!x86_match_cpu(longhaul_id))
                return -ENODEV;
 
+       if (!enable) {
+               printk(KERN_ERR PFX "Option \"enable\" not set. Aborting.\n");
+               return -ENODEV;
+       }
 #ifdef CONFIG_SMP
        if (num_online_cpus() > 1) {
                printk(KERN_ERR PFX "More than 1 CPU detected, "
@@ -1021,6 +1025,10 @@ MODULE_PARM_DESC(scale_voltage, "Scale voltage of processor");
  * such. */
 module_param(revid_errata, int, 0644);
 MODULE_PARM_DESC(revid_errata, "Ignore CPU Revision ID");
+/* By default driver is disabled to prevent incompatible
+ * system freeze. */
+module_param(enable, int, 0644);
+MODULE_PARM_DESC(enable, "Enable driver");
 
 MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
 MODULE_DESCRIPTION("Longhaul driver for VIA Cyrix processors.");
index 3265844839bfe9c79ef8849705262a52d16cc4e1..2a297f86dbad25be5f17e0f41029e92dd23afeaf 100644 (file)
@@ -209,7 +209,7 @@ inline int cpuidle_coupled_set_not_ready(struct cpuidle_coupled *coupled)
        int all;
        int ret;
 
-       all = coupled->online_count || (coupled->online_count << WAITING_BITS);
+       all = coupled->online_count | (coupled->online_count << WAITING_BITS);
        ret = atomic_add_unless(&coupled->ready_waiting_counts,
                -MAX_WAITING_CPUS, all);
 
index 8df53dd8dbe17b4bb0c0d432bbec56d31895dc84..fb4a7dd57f94f479adf8a3dd93e35e4f348b65d3 100644 (file)
@@ -70,7 +70,7 @@ int cpuidle_play_dead(void)
        struct cpuidle_device *dev = __this_cpu_read(cpuidle_devices);
        struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
        int i, dead_state = -1;
-       int power_usage = -1;
+       int power_usage = INT_MAX;
 
        if (!drv)
                return -ENODEV;
index 3af841fb397a0cda095b9ca794c04271c5164332..c2b281afe0ed03ce13a3a3122d96084319a93635 100644 (file)
@@ -235,16 +235,10 @@ EXPORT_SYMBOL_GPL(cpuidle_get_driver);
  */
 struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev)
 {
-       struct cpuidle_driver *drv;
-
        if (!dev)
                return NULL;
 
-       spin_lock(&cpuidle_driver_lock);
-       drv = __cpuidle_get_cpu_driver(dev->cpu);
-       spin_unlock(&cpuidle_driver_lock);
-
-       return drv;
+       return __cpuidle_get_cpu_driver(dev->cpu);
 }
 EXPORT_SYMBOL_GPL(cpuidle_get_cpu_driver);
 
index bd40b943b6db134eb30f0f6fe3fc0cf1dc7aaad0..20ea33afdda10c3e80ea99e716790c4494babf3e 100644 (file)
@@ -312,7 +312,7 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
 {
        struct menu_device *data = &__get_cpu_var(menu_devices);
        int latency_req = pm_qos_request(PM_QOS_CPU_DMA_LATENCY);
-       int power_usage = -1;
+       int power_usage = INT_MAX;
        int i;
        int multiplier;
        struct timespec t;
index c49c04d9c2b07b7cdb1a2372e4f383885339bcbc..4ba384f1ab544976621e6dc48c46dd0453687fef 100644 (file)
@@ -506,7 +506,7 @@ static int intel_idle_cpuidle_driver_init(void)
                        if (*cpuidle_state_table[cstate].name == '\0')
                                pr_debug(PREFIX "unaware of model 0x%x"
                                        " MWAIT %d please"
-                                       " contact lenb@kernel.org",
+                                       " contact lenb@kernel.org\n",
                                boot_cpu_data.x86_model, cstate);
                        continue;
                }
index cfaf5b73540bbc6b958ad7e5f15ea4822ab7c8d6..0c201317284b40e93014d0a574b3ef0ab9d81b9b 100644 (file)
@@ -298,6 +298,39 @@ static ssize_t pnp_show_current_resources(struct device *dmdev,
        return ret;
 }
 
+static char *pnp_get_resource_value(char *buf,
+                                   unsigned long type,
+                                   resource_size_t *start,
+                                   resource_size_t *end,
+                                   unsigned long *flags)
+{
+       if (start)
+               *start = 0;
+       if (end)
+               *end = 0;
+       if (flags)
+               *flags = 0;
+
+       /* TBD: allow for disabled resources */
+
+       buf = skip_spaces(buf);
+       if (start) {
+               *start = simple_strtoull(buf, &buf, 0);
+               if (end) {
+                       buf = skip_spaces(buf);
+                       if (*buf == '-') {
+                               buf = skip_spaces(buf + 1);
+                               *end = simple_strtoull(buf, &buf, 0);
+                       } else
+                               *end = *start;
+               }
+       }
+
+       /* TBD: allow for additional flags, e.g., IORESOURCE_WINDOW */
+
+       return buf;
+}
+
 static ssize_t pnp_set_current_resources(struct device *dmdev,
                                         struct device_attribute *attr,
                                         const char *ubuf, size_t count)
@@ -305,7 +338,6 @@ static ssize_t pnp_set_current_resources(struct device *dmdev,
        struct pnp_dev *dev = to_pnp_dev(dmdev);
        char *buf = (void *)ubuf;
        int retval = 0;
-       resource_size_t start, end;
 
        if (dev->status & PNP_ATTACHED) {
                retval = -EBUSY;
@@ -349,6 +381,10 @@ static ssize_t pnp_set_current_resources(struct device *dmdev,
                goto done;
        }
        if (!strnicmp(buf, "set", 3)) {
+               resource_size_t start;
+               resource_size_t end;
+               unsigned long flags;
+
                if (dev->active)
                        goto done;
                buf += 3;
@@ -357,42 +393,37 @@ static ssize_t pnp_set_current_resources(struct device *dmdev,
                while (1) {
                        buf = skip_spaces(buf);
                        if (!strnicmp(buf, "io", 2)) {
-                               buf = skip_spaces(buf + 2);
-                               start = simple_strtoul(buf, &buf, 0);
-                               buf = skip_spaces(buf);
-                               if (*buf == '-') {
-                                       buf = skip_spaces(buf + 1);
-                                       end = simple_strtoul(buf, &buf, 0);
-                               } else
-                                       end = start;
-                               pnp_add_io_resource(dev, start, end, 0);
-                               continue;
-                       }
-                       if (!strnicmp(buf, "mem", 3)) {
-                               buf = skip_spaces(buf + 3);
-                               start = simple_strtoul(buf, &buf, 0);
-                               buf = skip_spaces(buf);
-                               if (*buf == '-') {
-                                       buf = skip_spaces(buf + 1);
-                                       end = simple_strtoul(buf, &buf, 0);
-                               } else
-                                       end = start;
-                               pnp_add_mem_resource(dev, start, end, 0);
-                               continue;
-                       }
-                       if (!strnicmp(buf, "irq", 3)) {
-                               buf = skip_spaces(buf + 3);
-                               start = simple_strtoul(buf, &buf, 0);
-                               pnp_add_irq_resource(dev, start, 0);
-                               continue;
-                       }
-                       if (!strnicmp(buf, "dma", 3)) {
-                               buf = skip_spaces(buf + 3);
-                               start = simple_strtoul(buf, &buf, 0);
-                               pnp_add_dma_resource(dev, start, 0);
-                               continue;
-                       }
-                       break;
+                               buf = pnp_get_resource_value(buf + 2,
+                                                            IORESOURCE_IO,
+                                                            &start, &end,
+                                                            &flags);
+                               pnp_add_io_resource(dev, start, end, flags);
+                       } else if (!strnicmp(buf, "mem", 3)) {
+                               buf = pnp_get_resource_value(buf + 3,
+                                                            IORESOURCE_MEM,
+                                                            &start, &end,
+                                                            &flags);
+                               pnp_add_mem_resource(dev, start, end, flags);
+                       } else if (!strnicmp(buf, "irq", 3)) {
+                               buf = pnp_get_resource_value(buf + 3,
+                                                            IORESOURCE_IRQ,
+                                                            &start, NULL,
+                                                            &flags);
+                               pnp_add_irq_resource(dev, start, flags);
+                       } else if (!strnicmp(buf, "dma", 3)) {
+                               buf = pnp_get_resource_value(buf + 3,
+                                                            IORESOURCE_DMA,
+                                                            &start, NULL,
+                                                            &flags);
+                               pnp_add_dma_resource(dev, start, flags);
+                       } else if (!strnicmp(buf, "bus", 3)) {
+                               buf = pnp_get_resource_value(buf + 3,
+                                                            IORESOURCE_BUS,
+                                                            &start, &end,
+                                                            NULL);
+                               pnp_add_bus_resource(dev, start, end);
+                       } else
+                               break;
                }
                mutex_unlock(&pnp_res_mutex);
                goto done;
index ed9ce507149ab87efe8692b24379a82ab728184c..95cebf0185decdd48134892b43f5d45928ab3515 100644 (file)
 
 DEFINE_MUTEX(pnp_res_mutex);
 
+static struct resource *pnp_find_resource(struct pnp_dev *dev,
+                                         unsigned char rule,
+                                         unsigned long type,
+                                         unsigned int bar)
+{
+       struct resource *res = pnp_get_resource(dev, type, bar);
+
+       /* when the resource already exists, set its resource bits from rule */
+       if (res) {
+               res->flags &= ~IORESOURCE_BITS;
+               res->flags |= rule & IORESOURCE_BITS;
+       }
+
+       return res;
+}
+
 static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
 {
        struct resource *res, local_res;
 
-       res = pnp_get_resource(dev, IORESOURCE_IO, idx);
+       res = pnp_find_resource(dev, rule->flags, IORESOURCE_IO, idx);
        if (res) {
                pnp_dbg(&dev->dev, "  io %d already set to %#llx-%#llx "
                        "flags %#lx\n", idx, (unsigned long long) res->start,
@@ -65,7 +81,7 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
 {
        struct resource *res, local_res;
 
-       res = pnp_get_resource(dev, IORESOURCE_MEM, idx);
+       res = pnp_find_resource(dev, rule->flags, IORESOURCE_MEM, idx);
        if (res) {
                pnp_dbg(&dev->dev, "  mem %d already set to %#llx-%#llx "
                        "flags %#lx\n", idx, (unsigned long long) res->start,
@@ -78,6 +94,7 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
        res->start = 0;
        res->end = 0;
 
+       /* ??? rule->flags restricted to 8 bits, all tests bogus ??? */
        if (!(rule->flags & IORESOURCE_MEM_WRITEABLE))
                res->flags |= IORESOURCE_READONLY;
        if (rule->flags & IORESOURCE_MEM_CACHEABLE)
@@ -123,7 +140,7 @@ static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx)
                5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2
        };
 
-       res = pnp_get_resource(dev, IORESOURCE_IRQ, idx);
+       res = pnp_find_resource(dev, rule->flags, IORESOURCE_IRQ, idx);
        if (res) {
                pnp_dbg(&dev->dev, "  irq %d already set to %d flags %#lx\n",
                        idx, (int) res->start, res->flags);
@@ -182,7 +199,7 @@ static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx)
                1, 3, 5, 6, 7, 0, 2, 4
        };
 
-       res = pnp_get_resource(dev, IORESOURCE_DMA, idx);
+       res = pnp_find_resource(dev, rule->flags, IORESOURCE_DMA, idx);
        if (res) {
                pnp_dbg(&dev->dev, "  dma %d already set to %d flags %#lx\n",
                        idx, (int) res->start, res->flags);