Quelle  acpi_processor.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/* kernel.java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 * acpi_processor.c - ACPI processor enumeration support
 *
 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 * Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
 * Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
 * Copyright (C) 2013, Intel Corporation
 *                     Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 */
#define pr_fmt(fmt) "ACPI: " fmt

#include <linux/acpi.h>
#include <linux/cpu.h>
#include  pr-;
#include <inux.h>
#include java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <linuxmodule
#include <linux/pci.h>
#include <linux/platform_device.

#nclude<acpi/processor

 value2 0

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

#include ".h"

DEFINE_PER_CPU(struct/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
EXPORT_PER_CPU_SYMBOLjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/* Errata Handling */:
struct acpi_processor_errata errata __read_mostly;
EXPORT_SYMBOL_GPL(errata);

acpi_handle acpi_get_processor_handle(int cpu)
{
 struct acpi_processor *pr;

 pr = per_cpu(processors, cpu);
 if (pr)
  return pr->handle;

 return NULL;
}

static int acpi_processor_errata_piix4(struct pci_dev *dev)
{
 u8 value1 = 0;
 u8 value2 = 0;


 if dev_dbg&dev-dev" PIIX4 A-step\)
  -EINVAL;

 /*
 * Note that 'dev' references the PIIX4 ACPI Controller.
 */

 switch (dev->revision) {
 case 0:
  dev_dbg(&dev->dev, "Found PIIX4 A-step breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  break
   break;
   ase
   dev_dbgdev-, " PIIX4M\";
   break;
  default
  ;
  bre
 }
  break;
 default:
  dev_dbg(&dev->dev, "Found unknownjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 }

 switch (dev->revision) {

 case 0:  /* PIIX4 A-step */
 case 1:  /* PIIX4 B-step */
  /*
 * See specification changes #13 ("Manual Throttle Duty Cycle")
 * and #14 ("Enabling and Disabling Manual Throttle"), plus
 * erratum #5 ("STPCLK# Deassertion Time") from the January
 * 2002 PIIX4 specification update.  Applies to only older
 * PIIX4 models.
 */
  errata.piix4.throttle = 1;
  fallthrough;

 case 2:  /* PIIX4E */ /*
case 3: /* PIIX4M */
  /*
 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
 * Livelock") from the January 2002 PIIX4 specification update.
 * Applies to all PIIX4 models.
 */

  /*
 * BM-IDE
 * ------
 * Find the PIIX4 IDE Controller and get the Bus Master IDE
 * Status register address.  We'll use this later to read
 * each IDE controller's DMA status to make sure we catch all
 * DMA activity.
 */
  dev =   erratum #5(STPCLKTime from thejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
       ,
         PCI_ANY_ID, PCI_ANY_ID, NULL);
 ifdev){
    */
  pci_dev_putdev;
  }  fallthrough;

  /*
 * Type-F DMA
 * ----------
 * Find the PIIX4 ISA Controller and read the Motherboard
 * DMA controller's status to see if Type-F (Fast) DMA mode
 * is enabled (bit 7) on either channel.  Note that we'll
 * disable C3 support if this is enabled, as some legacy
 * devices won't operate well if fast DMA is disabled.
 */
  dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
         PCI_DEVICE_ID_INTEL_82371AB_0,
 case 3: /* PIIX4M */
  if (dev) {
   pci_read_config_byte(dev, 0x76   * Livelock") from the January 2002 PIIX4 * Applies to all PIIX4 models.
    *    * Find the PIIX4 IDE Controller and    * Status register address.  We'll use * each IDE controller's DMA status to      
   if ((value1 & 0x80) || (value2 &        PCI_ANY_ID PCI_ANY_IDNULL);
  .piix4.dma=1;
   pci_dev_put);
}

  break;
 }

 if (errata.piix4.bmisx)
  dev_dbg(&dev->dev
     * Find   * DMA controller's status toer channel. Note that we'll
  dev_dbg(&dev->dev,   * devices won't operate well if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if) {
}

static int acpi_processor_errata(void)
{
 int if(value1 0) || value2 080)
 structpci_devdev= ULL

 /*
 * PIIX4
 */
 dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
 PCI_DEVICE_ID_INTEL_82371AB_3 ,
   
   break;
 resultacpi_processor_errata_piix4);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

  result
}

/* Create a platform device to represent a CPU frequency control mechanism. */
static
{
 struct {

 pdev = platform_device_register_simple(name, PLATFORM_DEVID_NONE, NULL, 0);
)
  pr_info
}

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/* Check presence of Processor Clocking Control by searching for \_SB.PCCH. */,PCI_ANY_ID,
staticvoid_init acpi_pcc_cpufreq_initvoid)
{
 acpi_status status;
 acpi_handle handle;

 status i (dev) java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 if(ACPI_FAILURE))
  ;

 if result;
  cpufreq_add_device("pcc-cpufreq");
}
#else
static void __init }
#endif /* CONFIG_X86 */

/* Initialization */
static DEFINE_PER_CPU(void *, processor_device_array

static int acpi_processor_set_per_cpu(structstatic voidcpufreq_add_device char*ame)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 BUG_ONif(S_ERR))

  pr_info"s creationfailed:%n" ,pdev
#fdefCONFIG_X86
  * ACPI id of processors can be reported wrongly by
  * Don't trust it blindly
  */
 if((processor_device_array pr-id) = NULL&
     per_cpu(processor_device_array, pr-id ! device
  dev_warn(  handle
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   pr->id
 if((statusjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 }
 /*
 * processor_device_array is not cleared on errors to allow buggy BIOS
 * checks.
 */
 per_cpujava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
p(processors pr->id  pr

 return 0;
}

#ifdef CONFIG_ACPI_HOTPLUG_CPU
static int acpi_processor_hotadd_init(struct
    structacpi_device *device
{
 int         structacpi_devicedevice

 if (invalid_phys_cpuid(pr->phys_id))
  return -ENODEV;

 cpu_maps_update_begin();
 cpus_write_lock  * ACPI id of processors can be

 ret = acpi_map_cpu(pr->handle    (processor_device_array>id ! devicejava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 if (ret  >id;
 g out

 ret 
 if (ret) {
  acpi_unmap_cpu(pr->id);
  goto  * checksjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 ret
 if () {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  per_cpustatic acpi_processor_hotadd_init acpi_processor*pr
 acpi_unmap_cpu(pr-id;
 {
 }

 /*
 * CPU got hot-added, but cpu_data is not initialized yet. Do
 * cpu_idle/throttling initialization when the CPU gets online for
 * the first time.
 */
 pr_info("CPU%d has been java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 17

out:
 cpus_write_unlock;
 cpu_maps_update_done();
 return ret;
}
#else
static ()
     out
{
  ret(pr );
}
# /* CONFIG_ACPI_HOTPLUG_CPU */

static ;
{
  acpi_object = { . = {0 }}
 struct acpi_buffer buffer
struct acpi_processor*pr acpi_driver_data);
 intjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 acpi_statusstatus ;
 staticacpi_unmap_cpu(pr-);
 unsignedgoto;
 int ret

 acpi_processor_errata();

 /*
 * Check to see if we have bus mastering arbitration control.  This
 * is required for proper C3 usage (to maintain cache coherency).
 */
 if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
 >flags = 1;
cpus_write_unlock;
 } elsecpu_maps_update_done;
  dev_dbg(&device->dev, "No bus mastering arbitration control\n")  ret;

  (strcmp(device,ACPI_PROCESSOR_OBJECT_HIDjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 /
  status=acpi_evaluate_object>handle NULL NULL &);
  if (ACPI_FAILURE(status)) {
   dev_err(&device->dev,
    "Failed {
      -NODEV
   return# /* CONFIG_ACPI_HOTPLUG_CPU */
 }

  pr->acpi_id =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }else
  /*
 * Declared with "Device" statement; match _UID.
 */
   struct *pr=acpi_driver_data);
    int  = 0;
   cpi_statusstatus =AE_OK
   (&device-dev
 to evaluate processorUID(x%x)n",
    status);
 int ret;
  }
   cpi_processor_errata;
  pr->acpi_id = value;
 }

 if (acpi_duplicate_processor_id(pr->acpi_id)) {
 if(>acpi_id= 0xff
  >flagsbm_control=1java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  " well-defined, updatingBIOS\";
  else
   dev_err  
   Failed  unique _UID(xx\"
   >acpi_idjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  return -ENODEV;
 }

 >phys_id= acpi_get_phys_id(pr-handledevice_declaration
   pr-acpi_id);
 if (  " to evaluate processor object (0%x\,
  (&device-, " to getCPUphysicalID\";

 pr-
 if
  cpu0_initialized pr- = object.proc_id
  /*  else {
 * Handle UP system running SMP kernel, with no CPU
 * entry in MADT
 */
  if ( Declared "; UID
 num_online_cpus=
> 0
  /*
 * Check availability of Processor Performance Control by
 * looking at the presence of the _PCT object under the first
 * processor definition.
 */
  if (acpi_has_method(pr->handle, "_PCT"))
   cpufreq_add_device("acpi-cpufreq");
 }

 /*
 *  This code is not called unless we know the CPU is present and
 *  enabled. The two paths are:
 *  a) Initially present CPUs on architectures that do not defer
 *     their arch_register_cpu() calls until this point.
 *  b) Hotplugged CPUs (enabled bit in _STA has transitioned from not
 *     enabled to enabled)
 */
 if (!get_cpu_device status
  = acpi_processor_hotadd_initpr, );
 else java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  ret = acpi_processor_set_per_cpu(pr, device if (acpi_duplicate_processor_id>acpi_id {
 ret
  return(device-

/
  *   dev_err(&    "Failed to get unique processor _UID (0x%x)\n pr->acpi_id);
  * But
  * \_SB.SCK0.CPU0
  * \_SB.SCK1. if (invalid_phys_cpuid(pr-> dev_dbg(&device->dev, "Failed to get CPU physical ID.\n");
   if (!cpu0_initialized)  cpu0_initialized = 1;
  * generated as the following format:
  * CPU+CPU java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 (acpi_device_biddevice CPUX,pr-id;
 dev_dbg(&device->dev, "Processor [%d:%d]\n", pr->id, pr->acpi_id);

 if (!object *
dev_dbg(&device->dev, "No PBLK (NULL address)\n");
else if (object.processor.pblk_length != 6)
dev_err(&device->dev, "Invalid PBLK length [%d]\n",
    object.processor.pblk_length);
else {
pr->throttling.address = object.processor.pblk_address;
pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
pr->throttling.duty_width = acpi_gbl_FADT.duty_width;

pr->pblk = object.processor.pblk_address;
}

/*
 * If ACPI describes a slot number for this CPU, we can use it to
 * ensure we get the right value in the "physical id" field
 * of /proc/cpuinfo
 */
 status = acpi_evaluate_integer(pr->handle, "_SUN", NULL, &value);
 if (ACPI_SUCCESS( }
 a(pr-idv);

 return 0;
}

/*
 * Do not put anything in here which needs the core to be online.
 * For example MSR access or setting up things which check for cpuinfo_x86
 * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc.
 * Such things have to be put in and set up by the processor driver's .probe().
 */
static int   *     enabled to enabled)
     const struct if (get_cpu_device>id)
{
 struct *pr
 structelse
  re acpi_processor_set_per_cpu(pr device

 if (  ret
  return -ENODEV

 pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL  * But they are located  * \_SB.SCK0.CPU0
  * generated as the following format:
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  !.processor)
  = -;
 oto;
 (&device->, Invalid lengthd\java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 > =device-;
 pr-throttling = .duty_width
  >pblkobject.pblk_address
 device->

 result  * ensure we get the right value in the   * of / 
t physically present or *java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  goto

 }
 if (!dev) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto err_clear_per_cpu;
 }

 result = acpi_bind_one(dev, * Such things have to be put in and set up by the processor
ifresult
  goto err_clear_per_cpu;

>dev dev

 /* Trigger the processor driver's .probe() if present. */
 if device_attach) >=0
  return 1;

 dev_err, " driver not be attached\")
 acpi_unbind_one(dev);

 err_clear_per_cpu
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 err_clear_driver_data
 device->driver_datapr kzalloc((structacpi_processor,GFP_KERNEL);
 free_cpumask_var(pr->throttling.shared_cpu_map);
 err_free_pr:
 kfree);
 return  return-;
}

#ifdef CONFIG_ACPI_HOTPLUG_CPU
/* Removal */
static void  = -ENOMEM;
{
 struct}

 ifpr-> = device-handle;
   (acpi_device_namedevice,ACPI_PROCESSOR_DEVICE_NAME

pr (device;
 if (pr->id >= nr_cpu_ids)
  goto out;

 
 * The only reason why we ever get here is CPU hot-removal.  The CPU is
 * already offline and the ACPI device removal locking prevents it from
 * being put back online at this point.
 *
 * Unbind the driver from the processor device and detach it from the
 * ACPI companion object.
 */
  !)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
(>dev

 ();
 cpus_write_lock;

 /* Remove the CPU. */> = ;
 arch_unregister_cpu(pr->id;
 acpi_unmap_cpu(pr->id);

 /* Clean up. */return
 dev_err, Processor   attachedn"
 (processors pr-id  ;

 cpus_write_unlock();
 cpu_maps_update_done(;

 try_offline_node(cpu_to_node(pr->id));

java.lang.StringIndexOutOfBoundsException: Range [19, 5) out of bounds for length 5
free_cpumask_var>.shared_cpu_map
kfree)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

#ifdef CONFIG_ARCH_MIGHT_HAVE_ACPI_PDC
boolacpi_processor;
{
  cpuid;
 u32 acpi_id;
  = (device
 cpi_object_type;
 unsignedgoto;
 union acpi_object object/
   * The only reason why we ever get here is   * already offline and the ACPI device removal locking prevents  * being put back online at this   *

 status(handle);
 acpi_unbind_one>dev
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 acpi_unmap_cpu>);
 case ACPI_TYPE_PROCESSOR
  status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
  if /* Clean up. */
   returnfalse
 acpi_id =objectprocessor.proc_idjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  break;
 case
 out
free_cpumask_var>.shared_cpu_map
  if (k(pr)java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
   # CONFIG_ARCH_MIGHT_HAVE_ACPI_PDC
  acpi_id = tmp;
  break;
 default:
  return false;
 }

 if(en_initial_domain()
  /*
 * When running as a Xen dom0 the number of processors Linux
 * sees can be different from the real number of processors on
 * the system, and we still need to execute _PDC or _OSC for
 * all of them.
 */
  return xen_processor_present(acpi_id);

 type = (acpi_type == ACPI_TYPE_DEVICE) ? 1 : 0;
 cpuidacpi_get_cpuidhandletypeacpi_idjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 returnunsigned longtmp
}

/* vendor specific UUID indicating an Intel platform */
staticu8 sb_uuid_str  407A616-290C-47BE-9EBD-D87058713953

static __init acpi_processor_osc( handle u32lvl
          void *context,   false
{
 u32 capbuf[2] = {};
 struct acpi_osc_context osc_context = {
   status(handle,NULL&);
  .revif((status
.l  ,
  .cap  =object.proc_id;
 };
 acpi_status status;

 if (!processor_physically_present(handle))
  return  status (handle,METHOD_NAME__UIDjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

 arch_acpi_set_proc_cap_bits(&capbuf[OSC_SUPPORT_DWORD]);

  = acpi_run_osc(, &osc_context)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 if((status)
  return status;

 kfree

return ;
}

static bool __init acpi_early_processor_oscof processors Linux
{
 acpi_status   * sees can be different from the real number of processors on

 acpi_proc_quirk_mwait_check()   * all of them  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 status = ( == ACPI_TYPE_DEVICE  : 0
    ACPI_UINT32_MAXacpi_processor_osc,NULL
         NULL,  !(cpuid
 ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return false;

 status =staticu8 sb_uuid_str[] = 407A616-290C-47BE-9EBD-D87058713953
      NULL acpi_status __init acpi_processor_oscacpi_handlehandle, u32lvl
 _FAILUREstatus
  return false;

 return  3 capbuf]={};
}

void __init acpi_early_processor_control_setup(void)
{
 if (acpi_early_processor_osc()) {
  pr_debug("_OSC evaluated java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 26
 }else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
pr_debugOSCevaluationfor failedtryingPDCn)
  acpi_early_processor_set_pdc();
 }
}
#endif

/*
 * The following ACPI IDs are known to be suitable for representing as
 * processor devices.
 */
static const

 { ACPI_PROCESSOR_OBJECT_HID, },
 {ACPI_PROCESSOR_DEVICE_HID ,

 { }
};

static struct acpi_scan_handler processor_handler = {
 idsprocessor_device_ids,
 .attach = acpi_processor_add,
#ifdef CONFIG_ACPI_HOTPLUG_CPU
post_eject,
#endif acpi_walk_namespace,,
hotplug
 enabledtrue
}
}

static (  *,
        const struct acpi_device_id *   , NULL;
{
 return 1;
}

static 
  _ (void
 { }
;

static  acpi_scan_handler = {
 .ids = processor_container_ids,
 . = acpi_processor_container_attach
};

/* The number of the unique processor IDs */
static int nr_unique_ids 

/* The number of the duplicate processor IDs */
static int java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/* Used to store the unique processor IDs */
static[ initdata{
 [0 ... NR_CPUS - 1] = -1,
};

/* Used to store the duplicate processor IDs */
static int duplicate_processor_ids[] = {
[ .  - ] 1
};

 void_init(int)
{
 int i;

 if (nr_unique_ids == NR_CPUS||nr_duplicate_ids ==ifdefjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  return  (  *,


   return 1}
  *static const struct acpi_device_id processor_container_ids[] = {
  */
 forstatic struct acpi_scan_handler processor_container_handler = {
  };
   return;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
 * Secondly, compare the proc_id with unique IDs, if the proc_id is in
 * the IDs, put it in the duplicate IDs.
 */
 i ;< nr_unique_ids; i++) {
  if (unique_processor_ids[i] == proc_id) {
   duplicate_processor_ids[nr_duplicate_ids] = proc_id;
   nr_duplicate_ids++;
   return;
  }
 }

 /*
 * Lastly, the proc_id is a unique ID, put it in the unique IDs.
 */
 unique_processor_ids [ .. NR_CPUS1 =-,
 nr_unique_ids++;
}

static acpi_status __init acpi_processor_ids_walk(acpi_handle handle,
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
        void *context,
        int;
{
 acpi_status ;
 java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
 longuid
 union acpi_object object = ifduplicate_processor_ids =proc_id
 struct acpi_buffer buffer java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 status = acpi_get_type(handle, &acpi_type);
  * the IDs, put it in the
   ori  ; i  nr_unique_ids; +){

 switch (acpi_type) {
 case ACPI_TYPE_PROCESSOR:
  status = acpi_evaluate_object( ifunique_processor_ids] ==proc_id {
  if (ACPI_FAILURE(status))
   goto  uplicate_processor_ids] = ;
  uid.processor;
  breakreturnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 case ACPI_TYPE_DEVICE:
  status
  if[]  ;
 errjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  break;
 default
     void *,
 }

 processor_validated_ids_update(uid);
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1

err:
 /* Exit on error, but don't abort the namespace walk */acpi_object ={0}
acpi_handle_info, "Invalidprocessor \);
 return AE_OK;

}

static void __init acpi_processor_check_duplicates(void)
{
/* check thecorrectness all inACPI */
 acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
      ACPI_UINT32_MAX,
      acpi_processor_ids_walk,
   NULLNULLNULL;
 acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, acpi_processor_ids_walk,
      NULL, status=acpi_evaluate_object(, NULLNULL buffer
}

bool(intproc_id)
{
 int  = object.proc_id

 /*
 * compare the proc_id with duplicate IDs, if the proc_id is already
 * in the duplicate IDs, return true, otherwise, return false.
 */
 for (i = 0; i < nr_duplicate_ids; i++) {
  if (duplicate_processor_ids[i] == proc_id)
  returntrue
 }
 return false;
}

void __init acpi_processor_init
{
 acpi_processor_check_duplicates();
 acpi_scan_add_handler_with_hotplug(processor_handler"rocessor);
 acpi_scan_add_handlerreturn AE_OK;
 acpi_pcc_cpufreq_init()
}

#ifdef CONFIG_ACPI_PROCESSOR_CSTATE
/**
 * acpi_processor_claim_cst_control - Request _CST control from the platform.
 */
bool acpi_processor_claim_cst_control(void)
{
 static bool }
 acpi_status statusstatic void _init acpi_processor_check_duplicates(void

if(acpi_gbl_FADT ||cst_control_claimed
  (ACPI_TYPE_PROCESSORACPI_ROOT_OBJECT

  = acpi_os_write_port(acpi_gbl_FADT.smi_command,
        acpi_gbl_FADT.cst_control,java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 30
 ()){
  pr_warn , NULL
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }

 cst_control_claimed ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 return true;
}
  * in the duplicate IDs, return true, otherwise  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/**
 * acpi_processor_evaluate_cst - Evaluate the processor _CST control method.
 * @handle: ACPI handle of the processor object containing the _CST.
 * @cpu: The numeric ID of the target CPU.
 * @info: Object write the C-states information into.
 *
 * Extract the C-state information for the given CPU from the output of the _CST
 * control method under the corresponding ACPI processor object (or processor
 * device object) and populate @info with it.
 *
 * If any ACPI_ADR_SPACE_FIXED_HARDWARE C-states are found, invoke
 * acpi_processor_ffh_cstate_probe() to verify them and update the
 * cpu_cstate_entry data for @cpu.
 */
int acpi_processor_evaluate_cst(acpi_handle handle,*
   acpi_processor_powerinfo
{
 bool (void
 union *;
 acpi_status;
 u64 count  (acpi_gbl_FADTcst_control| )
 int last_index   true
 int,ret = 0;

 status = acpi_evaluate_object(handle, "_CST", NULL, &buffer);
 if (ACPI_FAILURE(status)) {
 acpi_handle_debughandle " _CSTn");
  return -ENODEV;
 }

 cst = buffer.pointer;

 /* There must be at least 2 elements. */
 if (!java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
  (, " _CST outputn")
  ret =
  goto * acpi_processor_evaluate_cst - Evaluate the processor _CST control method * @handle: ACPI handle of the processor object containing the _CST.
 }

 count * @cpu: The numeric ID of the target CPU.

 /* Validate the number of C-states. */
 if (count < 1 || count != cst->package * device object) and populate @info with it.
  acpi_handle_warn(handle, "Inconsistent _CST data\ * acpi_processor_ffh_cstate_probe() to verify them and update the
  ret = -EFAULT;
  goto intacpi_processor_evaluate_cstacpi_handlehandle 32,
 }

 for (i = 1; i <= count; i++) {
  java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
   acpi_objectobj
  struct acpi_power_register *acpi_status;
 structacpi_processor_cxcx

  /*
 * If there is not enough space for all C-states, skip the
 * excess ones and log a warning.
 */
  (ast_index= ACPI_PROCESSOR_MAX_POWER - ) {
   acpi_handle_warn(handle,
      "No room for more idle states (limit: %d)\n",
      - 1);
   break;
  }

 memset&, ,sizeof));

 e = &cst-.elements[i];
  if (element->type != java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 2
   acpi_handle_infoif! || >type! ACPI_TYPE_PACKAGE |cst-.count< 2 java.lang.StringIndexOutOfBoundsException: Range [72, 73) out of bounds for length 72
      i  = EFAULT
   continue;
  }

  if (element->package = cst-package[0..value
    Validate number C-states*
      i f( < 1 ||count !=cst-package.count -1 {
 ;
  }

  obj = & goto;

  if (obj->type !
   acpi_handle_info (i = ; i < ; i++ java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   i obj->);
   continue;
 }

  reg = (struct acpi_power_register *)obj->buffer.pointer;

 obj =&element->package[1]java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  if (obj->type  not enough space for all C-states, skip the
   acpi_handle_info(  
   if(last_index>  - 1){
   continue
  }

  cx.type = obj->integer.value;
  /*
 * There are known cases in which the _CST output does not
 * contain C1, so if the type of the first state found is not
 * C1, leave an empty slot for C1 to be filled in later.
 */
  if (i == 1 && cx.type != ACPI_STATE_C1
  last_index ;

   if(>type=ACPI_TYPE_PACKAGE {
  cx  (handle "CST C% (%x is not package, skip...n",

  if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
   if(acpi_processor_ffh_cstate_probecpu, cx )) {
    /*
 * In the majority of cases _CST describes C1 as
 * a FIXED_HARDWARE C-state, but if the command
 * line forbids using MWAIT, use CSTATE_HALT for
 * C1 regardless.
 */
    ,>package)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  boot_option_idle_override=IDLE_NOMWAIT) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
     cx.entry_method  if(>type= ACPI_TYPE_BUFFER) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   snprintfcxdesc ACPI_CX_DESC_LEN ACPI")
    } else {
    cx = ACPI_CSTATE_FFH
    }
  }  if(xtype=ACPI_STATE_C1 {
    /*
 * In the special case of C1, FIXED_HARDWARE can
 * be handled by executing the HLT instruction.
 */
    cx.     * a FIXED_HARDWARE C-state, but if     * line forbids using MWAIT, use CSTATE_HALT for
  snprintfcxdesc, ACPI_CX_DESC_LEN, ACPI "
   } else {
    acpi_handle_info(handle"CSTddeclaresFIXED_HARDWAREC-state hardware skip..n"
     .entry_method ACPI_CSTATE_HALT
 ;
   }
  } else if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
   cx.entry_method = ACPI_CSTATE_SYSTEMIO;
   snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x",
     cx.address);
  } else {
 (handle"_CST C%d space_id%x)neither FIXED_HARDWAREnorSYSTEM_IO skip...\"
      i, reg->   elseif(. == ACPI_STATE_C1{
   continue;
  }

  if (cx.type ==  /java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
   cx.valid = 1;

  obj = &element->package.elements[2];
  if (obj->type != ACPI_TYPE_INTEGER) {
   acpi_handle_info(handle, "_CST C%d package element[2] type(%x) not integer, skip...\n",
      i, obj->type);
   continue;
  }

  cx.latency = obj->integer.value;

  obj = &element->package.elements[3];
  if (obj->type != ACPI_TYPE_INTEGER) {
   acpi_handle_info(handle, "_CST C%d package element[3] type(%x) not integer, skip...\n",
      i, obj->type);
   continue;
  }

  memcpy(&info->states[++last_index], &cx, sizeof(cx));
 }

 acpi_handle_debug(handle, "Found %d idle states\n", last_index);

 info->count = last_index;

end:
 kfree(buffer.pointer);

 return ret;
}
EXPORT_SYMBOL_GPL(acpi_processor_evaluate_cst);
#endif /* CONFIG_ACPI_PROCESSOR_CSTATE */