Quelle  acpi_processor.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * 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 <linux/device.h>
#include <linux// SPDX-License-Identifier: GPL-2.0-only
nclude<linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/platform_device.h>

#include <acpi/processor.h>

#include <asm/cpu.h>

#include <xen/xen.h>

#include "internal.h"

DEFINE_PER_CPU(struct acpi_processor *, processors);
EXPORT_PER_CPU_SYMBOL(processors);

/* 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 * acpi_processor.c - ACPI  * Copyright (C) 2001, * Copyright (C) 200 * Copyright (C) 2004        * Copyright (C) 200 * Copyright (C *                     Rafael J. Wysocki <rafael.j.*/
 return>handle</dmi

 return NULL;
}

static int acpi_processor_errata_piix4(struct pci_dev/.h>
{
 # acpi.h>
u8 =0


 if (!dev)
  return -EINVALinternal

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

 switch (dev->revision) {
 case 0java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 (&>, Found\")
  break;
 case returnEINVAL
  dev_dbg(&dev->devjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ;
 case 2:
  dev_dbg(&dev->dev, "Found ;
 break
c 3:
 (&>devFoundn)
break
 :
break
 ak;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 switch (dev->revision) {

java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 case   * erratum   * 2002 PIIX4  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 
   * See java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    * Applies to all PIIX4 java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 5
 *erratum# "# Deassertion ")from January
   * 2002 PIIX4 specification update.  Applies to only older  PCI_DEVICE_ID_INTEL_82371AB
     ()
 /
 ()
 fallthrough

    * Find   * DMA controller   * is enabled   * disable C3   * devices 
case 
/*
 * 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 = pci_get_subsys(PCI_VENDOR_ID_INTEL,
         PCI_DEVICE_ID_INTEL_82371AB,
       ,, NULL
  if (dev) {
     errata. =1;
  (dev
  }  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /*
 * 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,
         PCI_ANY_ID, PCI_ANY_ID, NULL);
  (dev{
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
   ( &x80( &08)
    errata.piix4  * =N;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       ,PCI_ANY_ID

 break
 } = (dev

 if (errata.piix4.bmisx)
 }
 return;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return 0;
}

static
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct pci_dev *

 /*
 * PIIX4
 */
 dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
        PCI_DEVICE_ID_INTEL_82371AB_3 PCI_ANY_ID
        PCI_ANY_ID  _init(void
 f(dev{
  result = acpi_processor_errata_piix4(dev);
    ((status
return

turnjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

/* Create a platform device to represent a CPU frequency control mechanism. */
static (const *ame
{
 struct platform_device *pdev;

 pdev = platform_device_register_simple(name
  ((pdev
 ("device :%pe\,name );
}

# java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
/* Check presence of Processor Clocking Control by searching for \_SB.PCCH. */
static per_cpu,>id!  &
{
 acpi_status     per_cpuprocessor_device_array>)! ) {
 acpi_handle;

 status = acpi_get_handle(  pr-);
  ACPI_FAILURE))
  return;

 if (acpi_has_methodjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  cpufreq_add_device
}
#else
static void __ er_cpu,pr-)=;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* Initialization */
static acpi_device)

static
    *)
{
 BUG_ON(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
 * Buggy BIOS check.
 * ACPI id of processors can be reported wrongly by the BIOS.
 * Don't trust it blindly
 */
 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     per_cpu, pr-) ! ) {
  dev_warn(&device->dev,
    "BIOS reported wrong ACPI id %d for the processor\n",
  pr-)
   oto;
 }
 /*
 * processor_device_array is not cleared on errors to allow buggy BIOS
 * checks.
 */
 per_cpu(processor_device_array, pr->id) = device;
 per_cpu

 return ret
}

#ifdef CONFIG_ACPI_HOTPLUG_CPU
 int(struct *,
  acpi_unmap_cpu>);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int ret;

 if (  * cpu_idle/throttling initialization when the  * the
  return -ENODEV;

 cpu_maps_update_begin();
 cpus_write_lock

 ret()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 ifret
 goto;

 = acpi_processor_set_per_cpu,device
 ifendif
  acpi_unmap_cpu(pr-
out
  union objectprocessor   ;

 truct * =(device
 if (ret) {
  /* Leave the processor device array in place to detect buggy bios */
  per_cpu  =AE_OK
  acpi_unmap_cpu>id
   out
 }

 /*
 * 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(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

out pr-.bm_control;
 ()
 ()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
return;
}
#else
staticif!(acpi_device_hid) )) {
          struct acpi_device * /* Declared with "Processor" statement; match ProcessorID */  (pr-, ,, buffer
{
return-;
}
endif

static int 
{
 union acpi_object object = { .processor =   {
 struct acpi_buffer buffer
 acpi_processor  (device
 intdevice_declaration;
a status ;
 staticdev_err>,
  "Failed evaluate _ 0xx)",
 ntret

a()java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 /*
 * Check to see if we have bus mastering arbitration control.  This
 * is required for proper C3 usage (to maintain cache coherency).
 */
 if  pr- =0)
 pr-. =;
  dev_dbg(&device->dev, "Bus Entrynotwell-defined,consider n)
}else
 " toget processor _ 0%)n"

 if pr-);
  /* Declared with "Processor" statement; match ProcessorID */
  status
  pr- =acpi_get_phys_id>, ,
     >acpi_id
  Failed processor0%)n"
    status) dev_dbg>devFailed   .n)
   return 
  }

 >acpi_id.processor;
 }else
    * Handle UP system running SMP   * entry 
  * Declared with"Device statement;match _UID.
   */
  status     (num_online_cpus() ==1))
     pr->d = ;
  if (ACPI_FAILURE(status   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *  This code is not called unless we know the CPU is present and
    "Failed to evaluate processor _ * b) Hotplugged CPUs (enabled bit in * enabled to enabled)
   );
 ret(prdevice
 }
  device_declaration = 1;
  pr->acpi_id = value;
 }

if((pr-)) {
  if (pr->acpi_id == 0xffif (ret)
   dev_info_once&>dev,
    /*
else
dev_err(&device->dev,
"Failed to get unique processor _UID (0x%x)\n",
pr->acpi_id);
return -ENODEV;
}

pr->phys_id = acpi_get_phys_id(pr->handle, device_declaration,
pr->acpi_id);
if (invalid_phys_cpuid(pr->phys_id))
dev_dbg(&device->dev, "Failed to get CPU physical ID.\n");

pr->id = acpi_map_cpuid(pr->phys_id, pr->acpi_id);
if (!cpu0_initialized) {
cpu0_initialized = 1;
/*
 * Handle UP system running SMP kernel, with no CPU
 * entry in MADT
 */
  if (!acpi_has_cpu_in_madt() && invalid_logical_cpuid(pr->id) &&
   /
sprintf(),"%" >)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 /
   * Check availability  dev_dbg(&device->dev, "No PBLK ( else if (object.processor.pblk_length != 6)
   *       object.processor.pblk_length);
   * processor  pr->throttling.address = object.processor.pblk_address;
   */  pr->throttling.duty_width
  if (acpi_has_method }
   cpufreq_add_device  * If ACPI describes a slot number  * ensure we get the right  * of   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
  rch_fix_phys_package_id>, alue
 /*
 *  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((pr-)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   acpi_processor;
 else
t =acpi_processor_set_per_cpu, );
 
 return;

 /*
 * On some boxes several processors use the same processor bus id.
 * But they are located in different scope. For example:
 * \_SB.SCK0.CPU0
 * \_SB.SCK1.CPU0
 * Rename the processor device bus id. And the new bus id will be
 * generated as the following format:
 * CPU+CPU ID.
 */
 sprintf(acpi_device_bid(device), "CPU%X", pr->id);
 dev_dbg(&device-

 if(!bject.pblk_address
  resultENOMEM
 g err_free_pr
 dev_errdevice-dev" PBLK [%]\",
       object.processor.pblk_length);
 else {
  pr->throttling.address = object.processor.pblk_address;
  pr- pr-handle device->handle
 pr->.duty_width=acpi_gbl_FADT;

 pr- = .processor;
 }

 /*
 * 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 =  if (result) /* Processor is no present unavailable/
 if (ACPI_SUCCESS(status))
  arch_fix_phys_package_id(pr->id, value);

 return 0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
 * 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 acpi_processor_add(struct acpi_device * ()
    pr- = ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct acpi_processor if((dev )
 struct device(devProcessorcouldn";
 int:

 if (!acpi_device_is_enabled(device))
  return :

  =kzallocsizeof ) GFP_KERNELjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 (pr
  ENOMEM

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 resultENOMEM
  goto err_free_pr
 

 pr-handle>handle
strscpy() );
 strscpyp =acpi_driver_data)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 device->driver_data
 /*
result = acpi_processor_get_info(device);
if (result) /* Processor is not physically present or unavailable */
  goto  * being put back online at this point.

 dev = get_cpu_device(pr->id)  * ACPI companion object.
if(!dev {
  result = -ENODEV;
  goto err_clear_per_cpu;
 }

 result = acpi_bind_one acpi_unbind_onepr-);
 if (resultcpu_maps_update_begin
_per_cpu

 pr-devdev

 /* Trigger the processor driver's .probe() if present. */);
 if
   1;

 (dev" drivercouldnotbe \n";
 acpi_unbind_one(per_cpu,>)=NULL

 err_clear_per_cpucpu_maps_update_done)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 per_cpu(processors
 err_clear_driver_data:
 device->driver_data = NULL;
 free_cpumask_var(pr->throttling.shared_cpu_map);
 err_free_pr:
 kfree (pr-throttling);
 return result (pr;
}}

#ifdef CONFIG_ACPI_HOTPLUG_CPU
/* Removal */
static void acpi_processor_post_eject(struct acpi_device
{
uct  *pr

 if ( int, type
  return

pr acpi_driver_data);
 ifa acpi_type
  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.
 */
 device_release_driver(pr- = acpi_get_type, &acpi_type;
 (pr-);

 cpu_maps_update_begin();
 cpus_write_lock();

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

/* Clean up. */
  ;
    .processor;

 cpus_write_unlock();
 cpu_maps_update_done();

 try_offline_node(cpu_to_node(pr->id));

 :
 (pr-throttling);
 free;
}
#endif /* CONFIG_ACPI_HOTPLUG_CPU */

ifdefjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 (en_initial_domain)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   * sees can be different from the real number of processors   * the system, and we    * all of java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int cpuid, type = (, , );
 u32 acpi_id;
 acpi_status status;
 acpi_object_type
  long ;
 union acpi_object object
 struct acpi_buffer

 status = acpi_get_type u8[]="7";
 if acpi_status_initacpi_processor_oscacpi_handle,  ,
 return;

 switchjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 case ACPI_TYPE_PROCESSOR:
  = acpi_evaluate_object, NULL, , buffer
  if ACPI_FAILURE))
   return false  .ap.ength=8
 acpi_id .processorproc_idjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  breakjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case ACPI_TYPE_DEVICE:
  =acpi_evaluate_integer METHOD_NAME__UID,
            NULL, &tmp);
  if (ACPI_FAILURE(status))
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  acpi_id =  statusacpi_run_oschandleosc_context;
  break;
 default:
  return falseif ACPI_FAILURE))
 }

 if ( eturnAE_OK
  /*
 * 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 ) ?1:0
 cpuid     , acpi_processor_osc ,

 returninvalid_logical_cpuid);
}

/* vendor specific UUID indicating an Intel platform */
 sb_uuid_str"7";

static_init( handle ,
      if (ACPI())
{
u2[2  }
 struct java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  .uuid_str = sb_uuid_str,
  .rev = 1,
  .cap.length } else {
  .cap.pointer = capbuf,
 };
 acpi_status   pr_debug("_ CPUsfailed, trying _PDC\";

 if (!processor_physically_present
  return java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 6

 arch_acpi_set_proc_cap_bits(&capbuf

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (ACPI_FAILURE(status  ACPI_PROCESSOR_DEVICE_HID, }
  return status;

 kfree(osc_context.ret.pointer);

 return AE_OK;
}

static bool java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 acpi_status status. = processor_device_idsjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 .post_eject = acpi_processor_post_eject

 status= acpi_walk_namespace(ACPI_TYPE_PROCESSOR ACPI_ROOT_OBJECT
   . = {
   . = true,
 if }
};

 status = acpi_get_devicesstatic intacpi_processor_container_attachstructacpi_devicedev
   NULLNULL)
 if (ACPI_FAILURE(status))
  return false;

 return true;
}

void_initacpi_early_processor_control_setup)
{
 if (acpi_early_processor_osc()};
  pr_debugstaticstruct processor_container_handler
 } elseattach,
   pr_debug
  acpi_early_processor_set_pdc();

}
java.lang.NullPointerException

/*
 * The following ACPI IDs are known to be suitable for representing as
 * processor devices.
 */
static const struct acpi_device_id processor_device_ids[] = {

 { ACPI_PROCESSOR_OBJECT_HID int unique_processor_ids]__initdata = java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 { ACPI_PROCESSOR_DEVICE_HID, },

 { }
} 0 ..NR_CPUS1 = -1

static
staticvoid _ processor_validated_ids_update proc_id
 .attach = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 7
# CONFIG_ACPI_HOTPLUG_CPU
 .post_eject = acpi_processor_post_eject,
#endif
 .hotplug = {
  .enabled = true,
 },
};

static intacpi_processor_container_attachstructacpi_device*dev
  /*
{
return 1;
}

static const struct acpi_device_id processor_container_ids[] = {
{ ACPI_PROCESSOR_CONTAINER_HID, },
{ }
};

static struct acpi_scan_handler processor_container_handler = {
.ids = processor_container_ids,
.attach = acpi_processor_container_attach,
};

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

/* The number of the duplicate processor IDs */
static int nr_duplicate_ids;

/* Used to store the unique processor IDs */
static int unique_processor_ids[] __initdata = {
 [0  for( =0;i 
};

/* Used to store the duplicate processor IDs */
static
 0. - ] 1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
};

static void __init processor_validated_ids_update(int proc_id)
{
  i

 if (nr_unique_ids
   acpi_statusstatus

 /*
 * Firstly, compare the proc_id with duplicate IDs, if the proc_id is
 * already in the IDs, do nothing.
 */
 for  unsigned long ;
  ([i]= )
   return;
 }

 /*
 * Secondly, compare the proc_id with unique IDs, if the proc_id is in
 * the IDs, put it in the duplicate IDs.
 */
f (i=0 i<nr_unique_idsi+ java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  ([i]= ) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  d[nr_duplicate_idsproc_id
   nr_duplicate_ids = object.proc_id
   return;
  }
 }

 /*
 * Lastly, the proc_id is a unique ID, put it in the unique IDs.
 */
 unique_processor_ids[r_unique_ids=proc_id
  goto;
}

static acpi_status __init acpi_processor_ids_walk(acpi_handle handle,
       :
    void*ontext
        void **rv
{
 acpi_status status;
 acpi_object_type acpi_type;
 unsigned longerr
 union  object= 0}
 struct acpi_buffer buffer = {(handle" objectn";

 status = acpi_get_type
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return status;

 /* check the correctness for all processors in ACPI namespace */  for processors  namespacejava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    , , )java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  =acpi_evaluate_objecthandle, , &);
  if 
   goto err acpi_duplicate_processor_id proc_id
 uid.processor;
  break;

 case ACPI_TYPE_DEVICE:
  status = acpi_evaluate_integer(  * in the duplicate IDs, returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (ACPI_FAILURE  ;
   goto err
  break
 default:
  goto err;
 }

 processor_validated_ids_update(uid acpi_scan_add_handler_with_hotplug&, ""
 returnAE_OK

err:acpi_pcc_cpufreq_init;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 return AE_OKjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

}

staticvoid_initacpi_processor_check_duplicates()
{
  !.cst_control )
acpi_walk_namespace, ,
      ACPI_UINT32_MAXstatusacpi_os_write_portacpi_gbl_FADTsmi_command,
      acpi_processor_ids_walk,
      NULL, NULL, NULL);
 acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, if(ACPI_FAILUREstatus {
     NULL);
}

bool acpi_duplicate_processor_id(int proc_id)
{
 int;

 /*
 * 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++) {
  * acpi_processor_evaluate_cst - Evaluate the processor _CST e _CST.
 * @cpu: The numeric  * @info: Object write *
 }
 return false;
}

void __init acpi_processor_init(void)
{
 acpi_processor_check_duplicates();
 acpi_scan_add_handler_with_hotplug *
 acpi_scan_add_handler(&processor_container_handler);
 acpi_pcc_cpufreq_init();
}

# * cpu_cstate_entry data for @ *
**
 *  struct *)
 *{
bool acpi_processor_claim_cst_control)
{
 static acpi_objectcst
 acpi_status status

 if!acpi_gbl_FADT. || cst_control_claimed
 return;

 status =   i,ret= 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if  (, No\"
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  return false
 }

 cst_control_claimed = true;
 return true;
}
EXPORT_SYMBOL_GPL(acpi_processor_claim_cst_controlacpi_handle_warnhandleInvalid \";

/**
 * 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.
 */
 ( ,u cpu
    struct acpi_processor_powerjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 union acpi_object *cstunionacpi_object *;
  status
 u64   ;
 int last_index  /
 int i, ret = 0;

 status = if( > ACPI_PROCESSOR_MAX_POWER1 java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 if (ACPI_FAILURE ACPI_PROCESSOR_MAX_POWER)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  memset(cx0 (cx;
  return -ENODEV lement&>packageelements]java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 }

 cst = buffer.pointer;

 /* There must be at least 2 elements. */
  (cst|cst- =ACPI_TYPE_PACKAGE| >package <) {
  acpi_handle_warn(handle, "Invalid _CST output\n");
 ret-;
  goto end;
 }

 countcst->.elements]integer;

 the of. *
i count|count! >packagecount ){
   continue
  ret
  end
 }

 fori =1i =count){
  union acpi_object *element;
  union   ,obj-type
  struct acpi_power_register * java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   obj element-.elements;

  /*
 * If there is not enough space for all C-states, skip the
 * excess ones and log a warning.
 */
  ( =ACPI_PROCESSOR_MAX_POWER 
   acpi_handle_warn(handle;
     java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
      ACPI_PROCESSOR_MAX_POWER - 1);
   break;
  }

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

  element = &cst-  =1
  element- ! ){
 acpi_handle_info,_CST%type)ispackage.."
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   continue;   ((cpu&,reg
  }

      * In the majority of cases _  * a FIXED_HARDWARE C-state, but if the command
   acpi_handle_info(handle, "_CST C%d * C1 regardless.
   i element-.count;
   continue;
  }

  obj = &element->package       = IDLE_NOMWAIT{

  (bj- ! ACPI_TYPE_BUFFER{
   acpi_handle_info(handle, "_CST C% snprintf(cx.,," HLT;
      i, obj->type  .entry_method;
   continue  }else (. = ){
  }

  reg =      * be handled by executing the HLT instruction.

  obj = &element->package.elements[1];
  if (obj->type != ACPI_TYPE_INTEGER) {
   acpi_handle_info(handle, "_CST C[%d] package element[1] type(%x) is not integer, skip...\n",
      i, obj->type);
   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 = 1;

  cx.address = reg->address;
  cx.index = last_index + 1;

  if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
   if (!acpi_processor_ffh_cstate_probe(cpu, &cx, reg)) {
    /*
 * 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.
 */
    if (cx.type =  (.descACPI_CX_DESC_LEN"HLT);
        boot_option_idle_overrideacpi_handle_info, " C% butnotsupportedin ,..,
  cx = ACPI_CSTATE_HALT;
       continuejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    } else {
   acpi_handle_info, (   ,skipn,
    }
 }else  (xtype) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  *
 * In the special case of C1, FIXED_HARDWARE can
 * be handled by executing the HLT instruction.
 */
    cx.entry_method = ACPI_CSTATE_HALT;
    snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
   } else {
    acpi_handle_info(handle, "_CST C%d declares FIXED_HARDWARE C-state but not supported in hardware, skip...\n",
       i);
    continue;
   }
  } 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 {
   acpi_handle_info(handle, "_CST C%d space_id(%x) neither FIXED_HARDWARE nor SYSTEM_IO, skip...\n",
      i, reg->space_id);
   continue;
  }

  if (cx.type == ACPI_STATE_C1)
   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 */