drivers/acpi/interpreter/amstorob.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: amstorob - AML Interpreter object store support, store to object
   5  *              $Revision: 18 $
   6  *
   7  *****************************************************************************/
   8
   9 /*
  10  *  Copyright (C) 2000 R. Byron Moore
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27
  28 #include "acpi.h"
  29 #include "acparser.h"
  30 #include "acdispat.h"
  31 #include "acinterp.h"
  32 #include "amlcode.h"
  33 #include "acnamesp.h"
  34 #include "actables.h"
  35
  36
  37 #define _COMPONENT          INTERPRETER
  38          MODULE_NAME         ("amstorob")
  39
  40
  41 /*******************************************************************************
  42  *
  43  * FUNCTION:    Acpi_aml_store_object_to_object
  44  *
  45  * PARAMETERS:  *Val_desc           - Value to be stored
  46  *              *Dest_desc          - Object to receive the value
  47  *
  48  * RETURN:      Status
  49  *
  50  * DESCRIPTION: Store an object to another object.
  51  *
  52  *              The Assignment of an object to another (not named) object
  53  *              is handled here.
  54  *              The val passed in will replace the current value (if any)
  55  *              with the input value.
  56  *
  57  *              When storing into an object the data is converted to the
  58  *              target object type then stored in the object.  This means
  59  *              that the target object type (for an initialized target) will
  60  *              not be changed by a store operation.
  61  *
  62  *              This module allows destination types of Number, String,
  63  *              and Buffer.
  64  *
  65  ******************************************************************************/
  66
  67 ACPI_STATUS
  68 acpi_aml_store_object_to_object (
  69         ACPI_OPERAND_OBJECT     *val_desc,
  70         ACPI_OPERAND_OBJECT     *dest_desc,
  71         ACPI_WALK_STATE         *walk_state)
  72 {
  73         ACPI_STATUS             status = AE_OK;
  74         u8                      *buffer = NULL;
  75         u32                     length = 0;
  76         OBJECT_TYPE_INTERNAL    destination_type = dest_desc->common.type;
  77
  78
  79         /*
  80          *  Assuming the parameters are valid!!!
  81          */
  82         ACPI_ASSERT((dest_desc) && (val_desc));
  83
  84         /*
  85          *  First ensure we have a value that can be stored in the target
  86          */
  87         switch (destination_type)
  88         {
  89                 /* Type of Name's existing value */
  90
  91         case ACPI_TYPE_NUMBER:
  92
  93                 /*
  94                  *  These cases all require only number values or values that
  95                  *  can be converted to numbers.
  96                  *
  97                  *  If value is not a Number, try to resolve it to one.
  98                  */
  99
 100                 if (val_desc->common.type != ACPI_TYPE_NUMBER) {
 101                         /*
 102                          *  Initially not a number, convert
 103                          */
 104                         status = acpi_aml_resolve_to_value (&val_desc, walk_state);
 105                         if (ACPI_SUCCESS (status) &&
 106                                 (val_desc->common.type != ACPI_TYPE_NUMBER))
 107                         {
 108                                 /*
 109                                  *  Conversion successful but still not a number
 110                                  */
 111                                 status = AE_AML_OPERAND_TYPE;
 112                         }
 113                 }
 114
 115                 break;
 116
 117         case ACPI_TYPE_STRING:
 118         case ACPI_TYPE_BUFFER:
 119
 120                 /*
 121                  *  Storing into a Field in a region or into a buffer or into
 122                  *  a string all is essentially the same.
 123                  *
 124                  *  If value is not a valid type, try to resolve it to one.
 125                  */
 126
 127                 if ((val_desc->common.type != ACPI_TYPE_NUMBER) &&
 128                         (val_desc->common.type != ACPI_TYPE_BUFFER) &&
 129                         (val_desc->common.type != ACPI_TYPE_STRING))
 130                 {
 131                         /*
 132                          *  Initially not a valid type, convert
 133                          */
 134                         status = acpi_aml_resolve_to_value (&val_desc, walk_state);
 135                         if (ACPI_SUCCESS (status) &&
 136                                 (val_desc->common.type != ACPI_TYPE_NUMBER) &&
 137                                 (val_desc->common.type != ACPI_TYPE_BUFFER) &&
 138                                 (val_desc->common.type != ACPI_TYPE_STRING))
 139                         {
 140                                 /*
 141                                  *  Conversion successful but still not a valid type
 142                                  */
 143                                 status = AE_AML_OPERAND_TYPE;
 144                         }
 145                 }
 146                 break;
 147
 148
 149         default:
 150
 151                 /*
 152                  * TBD: [Unhandled] What other combinations must be implemented?
 153                  */
 154                 status = AE_NOT_IMPLEMENTED;
 155                 break;
 156         }
 157
 158         /* Exit now if failure above */
 159
 160         if (ACPI_FAILURE (status)) {
 161                 goto clean_up_and_bail_out;
 162         }
 163
 164         /*
 165          * Acpi_everything is ready to execute now, We have
 166          * a value we can handle, just perform the update
 167          */
 168
 169         switch (destination_type)
 170         {
 171
 172         case ACPI_TYPE_STRING:
 173
 174                 /*
 175                  *  Perform the update
 176                  */
 177
 178                 switch (val_desc->common.type)
 179                 {
 180                 case ACPI_TYPE_NUMBER:
 181                         buffer = (u8 *) &val_desc->number.value;
 182                         length = sizeof (val_desc->number.value);
 183                         break;
 184
 185                 case ACPI_TYPE_BUFFER:
 186                         buffer = (u8 *) val_desc->buffer.pointer;
 187                         length = val_desc->buffer.length;
 188                         break;
 189
 190                 case ACPI_TYPE_STRING:
 191                         buffer = (u8 *) val_desc->string.pointer;
 192                         length = val_desc->string.length;
 193                         break;
 194                 }
 195
 196                 /*
 197                  *  Setting a string value replaces the old string
 198                  */
 199
 200                 if (length < dest_desc->string.length) {
 201                         /*
 202                          *  Zero fill, not willing to do pointer arithmetic for
 203                          *  architecture independence.  Just clear the whole thing
 204                          */
 205                         MEMSET(dest_desc->string.pointer, 0, dest_desc->string.length);
 206                         MEMCPY(dest_desc->string.pointer, buffer, length);
 207                 }
 208                 else {
 209                         /*
 210                          *  Free the current buffer, then allocate a buffer
 211                          *  large enough to hold the value
 212                          */
 213                         if ( dest_desc->string.pointer &&
 214                                 !acpi_tb_system_table_pointer (dest_desc->string.pointer))
 215                         {
 216                                 /*
 217                                  *  Only free if not a pointer into the DSDT
 218                                  */
 219
 220                                 acpi_cm_free(dest_desc->string.pointer);
 221                         }
 222
 223                         dest_desc->string.pointer = acpi_cm_allocate (length + 1);
 224                         dest_desc->string.length = length;
 225
 226                         if (!dest_desc->string.pointer) {
 227                                 status = AE_NO_MEMORY;
 228                                 goto clean_up_and_bail_out;
 229                         }
 230
 231                         MEMCPY(dest_desc->string.pointer, buffer, length);
 232                 }
 233                 break;
 234
 235
 236         case ACPI_TYPE_BUFFER:
 237
 238                 /*
 239                  *  Perform the update to the buffer
 240                  */
 241
 242                 switch (val_desc->common.type)
 243                 {
 244                 case ACPI_TYPE_NUMBER:
 245                         buffer = (u8 *) &val_desc->number.value;
 246                         length = sizeof (val_desc->number.value);
 247                         break;
 248
 249                 case ACPI_TYPE_BUFFER:
 250                         buffer = (u8 *) val_desc->buffer.pointer;
 251                         length = val_desc->buffer.length;
 252                         break;
 253
 254                 case ACPI_TYPE_STRING:
 255                         buffer = (u8 *) val_desc->string.pointer;
 256                         length = val_desc->string.length;
 257                         break;
 258                 }
 259
 260                 /*
 261                  * If the buffer is uninitialized,
 262                  *  memory needs to be allocated for the copy.
 263                  */
 264                 if(0 == dest_desc->buffer.length) {
 265                         dest_desc->buffer.pointer = acpi_cm_callocate(length);
 266                         dest_desc->buffer.length = length;
 267
 268                         if (!dest_desc->buffer.pointer) {
 269                                 status = AE_NO_MEMORY;
 270                                 goto clean_up_and_bail_out;
 271                         }
 272                 }
 273
 274                 /*
 275                  *  Buffer is a static allocation,
 276                  *  only place what will fit in the buffer.
 277                  */
 278                 if (length <= dest_desc->buffer.length) {
 279                         /*
 280                          *  Zero fill first, not willing to do pointer arithmetic for
 281                          *  architecture independence.  Just clear the whole thing
 282                          */
 283                         MEMSET(dest_desc->buffer.pointer, 0, dest_desc->buffer.length);
 284                         MEMCPY(dest_desc->buffer.pointer, buffer, length);
 285                 }
 286                 else {
 287                         /*
 288                          *  truncate, copy only what will fit
 289                          */
 290                         MEMCPY(dest_desc->buffer.pointer, buffer, dest_desc->buffer.length);
 291                 }
 292                 break;
 293
 294         case ACPI_TYPE_NUMBER:
 295
 296                 dest_desc->number.value = val_desc->number.value;
 297
 298                 /* Truncate value if we are executing from a 32-bit ACPI table */
 299
 300                 acpi_aml_truncate_for32bit_table (dest_desc, walk_state);
 301                 break;
 302
 303         default:
 304
 305                 /*
 306                  * All other types than Alias and the various Fields come here.
 307                  * Store Val_desc as the new value of the Name, and set
 308                  * the Name's type to that of the value being stored in it.
 309                  * Val_desc reference count is incremented by Attach_object.
 310                  */
 311
 312                 status = AE_NOT_IMPLEMENTED;
 313                 break;
 314         }
 315
 316 clean_up_and_bail_out:
 317
 318         return (status);
 319 }
 320