Print this page
acpica-unix2-20130823
PANKOVs restructure
   1 /******************************************************************************
   2  *
   3  * Module Name: exfield - ACPI AML (p-code) execution - field manipulation
   4  *
   5  *****************************************************************************/
   6 
   7 /*
   8  * Copyright (C) 2000 - 2011, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.


  96         return_ACPI_STATUS (AE_BAD_PARAMETER);
  97     }
  98 
  99     if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
 100     {
 101         /*
 102          * If the BufferField arguments have not been previously evaluated,
 103          * evaluate them now and save the results.
 104          */
 105         if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
 106         {
 107             Status = AcpiDsGetBufferFieldArguments (ObjDesc);
 108             if (ACPI_FAILURE (Status))
 109             {
 110                 return_ACPI_STATUS (Status);
 111             }
 112         }
 113     }
 114     else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 115              (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||

 116               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI))
 117     {
 118         /*
 119          * This is an SMBus or IPMI read. We must create a buffer to hold
 120          * the data and then directly access the region handler.
 121          *
 122          * Note: Smbus protocol value is passed in upper 16-bits of Function
 123          */
 124         if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS)
 125         {
 126             Length = ACPI_SMBUS_BUFFER_SIZE;
 127             Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);
 128         }





 129         else /* IPMI */
 130         {
 131             Length = ACPI_IPMI_BUFFER_SIZE;
 132             Function = ACPI_READ;
 133         }
 134 
 135         BufferDesc = AcpiUtCreateBufferObject (Length);
 136         if (!BufferDesc)
 137         {
 138             return_ACPI_STATUS (AE_NO_MEMORY);
 139         }
 140 
 141         /* Lock entire transaction if requested */
 142 
 143         AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 144 
 145         /* Call the region handler for the read */
 146 
 147         Status = AcpiExAccessRegion (ObjDesc, 0,
 148                     ACPI_CAST_PTR (UINT64, BufferDesc->Buffer.Pointer),


 257         return_ACPI_STATUS (AE_AML_NO_OPERAND);
 258     }
 259 
 260     if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
 261     {
 262         /*
 263          * If the BufferField arguments have not been previously evaluated,
 264          * evaluate them now and save the results.
 265          */
 266         if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
 267         {
 268             Status = AcpiDsGetBufferFieldArguments (ObjDesc);
 269             if (ACPI_FAILURE (Status))
 270             {
 271                 return_ACPI_STATUS (Status);
 272             }
 273         }
 274     }
 275     else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 276              (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||

 277               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI))
 278     {
 279         /*
 280          * This is an SMBus or IPMI write. We will bypass the entire field
 281          * mechanism and handoff the buffer directly to the handler. For
 282          * these address spaces, the buffer is bi-directional; on a write,
 283          * return data is returned in the same buffer.
 284          *
 285          * Source must be a buffer of sufficient size:
 286          * ACPI_SMBUS_BUFFER_SIZE or ACPI_IPMI_BUFFER_SIZE.
 287          *
 288          * Note: SMBus protocol type is passed in upper 16-bits of Function
 289          */
 290         if (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)
 291         {
 292             ACPI_ERROR ((AE_INFO,
 293                 "SMBus or IPMI write requires Buffer, found type %s",
 294                 AcpiUtGetObjectTypeName (SourceDesc)));
 295 
 296             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 297         }
 298 
 299         if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS)
 300         {
 301             Length = ACPI_SMBUS_BUFFER_SIZE;
 302             Function = ACPI_WRITE | (ObjDesc->Field.Attribute << 16);
 303         }





 304         else /* IPMI */
 305         {
 306             Length = ACPI_IPMI_BUFFER_SIZE;
 307             Function = ACPI_WRITE;
 308         }
 309 
 310         if (SourceDesc->Buffer.Length < Length)
 311         {
 312             ACPI_ERROR ((AE_INFO,
 313                 "SMBus or IPMI write requires Buffer of length %u, found length %u",
 314                 Length, SourceDesc->Buffer.Length));
 315 
 316             return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);
 317         }
 318 
 319         /* Create the bi-directional buffer */
 320 
 321         BufferDesc = AcpiUtCreateBufferObject (Length);
 322         if (!BufferDesc)
 323         {
 324             return_ACPI_STATUS (AE_NO_MEMORY);
 325         }
 326 
 327         Buffer = BufferDesc->Buffer.Pointer;
 328         ACPI_MEMCPY (Buffer, SourceDesc->Buffer.Pointer, Length);
 329 
 330         /* Lock entire transaction if requested */
 331 
 332         AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 333 
 334         /*
 335          * Perform the write (returns status and perhaps data in the
 336          * same buffer)
 337          */
 338         Status = AcpiExAccessRegion (ObjDesc, 0,
 339                     (UINT64 *) Buffer, Function);
 340         AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 341 
 342         *ResultDesc = BufferDesc;
 343         return_ACPI_STATUS (Status);
 344     }
 345 
 346     /* Get a pointer to the data to be written */
 347 
 348     switch (SourceDesc->Common.Type)
 349     {
 350     case ACPI_TYPE_INTEGER:

 351         Buffer = &SourceDesc->Integer.Value;
 352         Length = sizeof (SourceDesc->Integer.Value);
 353         break;
 354 
 355     case ACPI_TYPE_BUFFER:

 356         Buffer = SourceDesc->Buffer.Pointer;
 357         Length = SourceDesc->Buffer.Length;
 358         break;
 359 
 360     case ACPI_TYPE_STRING:

 361         Buffer = SourceDesc->String.Pointer;
 362         Length = SourceDesc->String.Length;
 363         break;
 364 
 365     default:

 366         return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 367     }
 368 
 369     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 370         "FieldWrite [FROM]: Obj %p (%s:%X), Buf %p, ByteLen %X\n",
 371         SourceDesc, AcpiUtGetTypeName (SourceDesc->Common.Type),
 372         SourceDesc->Common.Type, Buffer, Length));
 373 
 374     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 375         "FieldWrite [TO]:   Obj %p (%s:%X), BitLen %X, BitOff %X, ByteOff %X\n",
 376         ObjDesc, AcpiUtGetTypeName (ObjDesc->Common.Type),
 377         ObjDesc->Common.Type,
 378         ObjDesc->CommonField.BitLength,
 379         ObjDesc->CommonField.StartFieldBitOffset,
 380         ObjDesc->CommonField.BaseByteOffset));
 381 
 382     /* Lock entire transaction if requested */
 383 
 384     AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 385 
 386     /* Write to the field */
 387 
 388     Status = AcpiExInsertIntoField (ObjDesc, Buffer, Length);
 389     AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 390 
 391     return_ACPI_STATUS (Status);
 392 }
 393 
 394 
   1 /******************************************************************************
   2  *
   3  * Module Name: exfield - ACPI AML (p-code) execution - field manipulation
   4  *
   5  *****************************************************************************/
   6 
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.


  96         return_ACPI_STATUS (AE_BAD_PARAMETER);
  97     }
  98 
  99     if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
 100     {
 101         /*
 102          * If the BufferField arguments have not been previously evaluated,
 103          * evaluate them now and save the results.
 104          */
 105         if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
 106         {
 107             Status = AcpiDsGetBufferFieldArguments (ObjDesc);
 108             if (ACPI_FAILURE (Status))
 109             {
 110                 return_ACPI_STATUS (Status);
 111             }
 112         }
 113     }
 114     else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 115              (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||
 116               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS ||
 117               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI))
 118     {
 119         /*
 120          * This is an SMBus, GSBus or IPMI read. We must create a buffer to hold
 121          * the data and then directly access the region handler.
 122          *
 123          * Note: SMBus and GSBus protocol value is passed in upper 16-bits of Function
 124          */
 125         if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS)
 126         {
 127             Length = ACPI_SMBUS_BUFFER_SIZE;
 128             Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);
 129         }
 130         else if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS)
 131         {
 132             Length = ACPI_GSBUS_BUFFER_SIZE;
 133             Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);
 134         }
 135         else /* IPMI */
 136         {
 137             Length = ACPI_IPMI_BUFFER_SIZE;
 138             Function = ACPI_READ;
 139         }
 140 
 141         BufferDesc = AcpiUtCreateBufferObject (Length);
 142         if (!BufferDesc)
 143         {
 144             return_ACPI_STATUS (AE_NO_MEMORY);
 145         }
 146 
 147         /* Lock entire transaction if requested */
 148 
 149         AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 150 
 151         /* Call the region handler for the read */
 152 
 153         Status = AcpiExAccessRegion (ObjDesc, 0,
 154                     ACPI_CAST_PTR (UINT64, BufferDesc->Buffer.Pointer),


 263         return_ACPI_STATUS (AE_AML_NO_OPERAND);
 264     }
 265 
 266     if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
 267     {
 268         /*
 269          * If the BufferField arguments have not been previously evaluated,
 270          * evaluate them now and save the results.
 271          */
 272         if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
 273         {
 274             Status = AcpiDsGetBufferFieldArguments (ObjDesc);
 275             if (ACPI_FAILURE (Status))
 276             {
 277                 return_ACPI_STATUS (Status);
 278             }
 279         }
 280     }
 281     else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 282              (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||
 283               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS ||
 284               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI))
 285     {
 286         /*
 287          * This is an SMBus, GSBus or IPMI write. We will bypass the entire field
 288          * mechanism and handoff the buffer directly to the handler. For
 289          * these address spaces, the buffer is bi-directional; on a write,
 290          * return data is returned in the same buffer.
 291          *
 292          * Source must be a buffer of sufficient size:
 293          * ACPI_SMBUS_BUFFER_SIZE, ACPI_GSBUS_BUFFER_SIZE, or ACPI_IPMI_BUFFER_SIZE.
 294          *
 295          * Note: SMBus and GSBus protocol type is passed in upper 16-bits of Function
 296          */
 297         if (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)
 298         {
 299             ACPI_ERROR ((AE_INFO,
 300                 "SMBus/IPMI/GenericSerialBus write requires Buffer, found type %s",
 301                 AcpiUtGetObjectTypeName (SourceDesc)));
 302 
 303             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 304         }
 305 
 306         if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS)
 307         {
 308             Length = ACPI_SMBUS_BUFFER_SIZE;
 309             Function = ACPI_WRITE | (ObjDesc->Field.Attribute << 16);
 310         }
 311         else if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS)
 312         {
 313             Length = ACPI_GSBUS_BUFFER_SIZE;
 314             Function = ACPI_WRITE | (ObjDesc->Field.Attribute << 16);
 315         }
 316         else /* IPMI */
 317         {
 318             Length = ACPI_IPMI_BUFFER_SIZE;
 319             Function = ACPI_WRITE;
 320         }
 321 
 322         if (SourceDesc->Buffer.Length < Length)
 323         {
 324             ACPI_ERROR ((AE_INFO,
 325                 "SMBus/IPMI/GenericSerialBus write requires Buffer of length %u, found length %u",
 326                 Length, SourceDesc->Buffer.Length));
 327 
 328             return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);
 329         }
 330 
 331         /* Create the bi-directional buffer */
 332 
 333         BufferDesc = AcpiUtCreateBufferObject (Length);
 334         if (!BufferDesc)
 335         {
 336             return_ACPI_STATUS (AE_NO_MEMORY);
 337         }
 338 
 339         Buffer = BufferDesc->Buffer.Pointer;
 340         ACPI_MEMCPY (Buffer, SourceDesc->Buffer.Pointer, Length);
 341 
 342         /* Lock entire transaction if requested */
 343 
 344         AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 345 
 346         /*
 347          * Perform the write (returns status and perhaps data in the
 348          * same buffer)
 349          */
 350         Status = AcpiExAccessRegion (ObjDesc, 0,
 351                     (UINT64 *) Buffer, Function);
 352         AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 353 
 354         *ResultDesc = BufferDesc;
 355         return_ACPI_STATUS (Status);
 356     }
 357 
 358     /* Get a pointer to the data to be written */
 359 
 360     switch (SourceDesc->Common.Type)
 361     {
 362     case ACPI_TYPE_INTEGER:
 363 
 364         Buffer = &SourceDesc->Integer.Value;
 365         Length = sizeof (SourceDesc->Integer.Value);
 366         break;
 367 
 368     case ACPI_TYPE_BUFFER:
 369 
 370         Buffer = SourceDesc->Buffer.Pointer;
 371         Length = SourceDesc->Buffer.Length;
 372         break;
 373 
 374     case ACPI_TYPE_STRING:
 375 
 376         Buffer = SourceDesc->String.Pointer;
 377         Length = SourceDesc->String.Length;
 378         break;
 379 
 380     default:
 381 
 382         return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 383     }
 384 
 385     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 386         "FieldWrite [FROM]: Obj %p (%s:%X), Buf %p, ByteLen %X\n",
 387         SourceDesc, AcpiUtGetTypeName (SourceDesc->Common.Type),
 388         SourceDesc->Common.Type, Buffer, Length));
 389 
 390     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 391         "FieldWrite [TO]:   Obj %p (%s:%X), BitLen %X, BitOff %X, ByteOff %X\n",
 392         ObjDesc, AcpiUtGetTypeName (ObjDesc->Common.Type),
 393         ObjDesc->Common.Type,
 394         ObjDesc->CommonField.BitLength,
 395         ObjDesc->CommonField.StartFieldBitOffset,
 396         ObjDesc->CommonField.BaseByteOffset));
 397 
 398     /* Lock entire transaction if requested */
 399 
 400     AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 401 
 402     /* Write to the field */
 403 
 404     Status = AcpiExInsertIntoField (ObjDesc, Buffer, Length);
 405     AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 406 
 407     return_ACPI_STATUS (Status);
 408 }