lib/acpi/acpi_device.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Generation of tables for particular device types
   4  *
   5  * Copyright 2019 Google LLC
   6  * Mostly taken from coreboot file of the same name
   7  */
   8
   9 #include <dm.h>
  10 #include <irq.h>
  11 #include <log.h>
  12 #include <usb.h>
  13 #include <acpi/acpigen.h>
  14 #include <acpi/acpi_device.h>
  15 #include <acpi/acpigen.h>
  16 #include <asm-generic/gpio.h>
  17 #include <dm/acpi.h>
  18
  19 /**
  20  * acpi_device_path_fill() - Find the root device and build a path from there
  21  *
  22  * This recursively reaches back to the root device and progressively adds path
  23  * elements until the device is reached.
  24  *
  25  * @dev: Device to return path of
  26  * @buf: Buffer to hold the path
  27  * @buf_len: Length of buffer
  28  * @cur: Current position in the buffer
  29  * Return: new position in buffer after adding @dev, or -ve on error
  30  */
  31 static int acpi_device_path_fill(const struct udevice *dev, char *buf,
  32                                  size_t buf_len, int cur)
  33 {
  34         char name[ACPI_NAME_MAX];
  35         int next = 0;
  36         int ret;
  37
  38         ret = acpi_get_name(dev, name);
  39         if (ret)
  40                 return ret;
  41
  42         /*
  43          * Make sure this name segment will fit, including the path segment
  44          * separator and possible NULL terminator, if this is the last segment.
  45          */
  46         if (cur + strlen(name) + 2 > buf_len)
  47                 return -ENOSPC;
  48
  49         /* Walk up the tree to the root device */
  50         if (dev_get_parent(dev)) {
  51                 next = acpi_device_path_fill(dev_get_parent(dev), buf, buf_len,
  52                                              cur);
  53                 if (next < 0)
  54                         return next;
  55         }
  56
  57         /* Fill in the path from the root device */
  58         next += snprintf(buf + next, buf_len - next, "%s%s",
  59                          dev_get_parent(dev) && *name ? "." : "", name);
  60
  61         return next;
  62 }
  63
  64 int acpi_device_path(const struct udevice *dev, char *buf, int maxlen)
  65 {
  66         int ret;
  67
  68         ret = acpi_device_path_fill(dev, buf, maxlen, 0);
  69         if (ret < 0)
  70                 return ret;
  71
  72         return 0;
  73 }
  74
  75 int acpi_device_scope(const struct udevice *dev, char *scope, int maxlen)
  76 {
  77         int ret;
  78
  79         if (!dev_get_parent(dev))
  80                 return log_msg_ret("noparent", -EINVAL);
  81
  82         ret = acpi_device_path_fill(dev_get_parent(dev), scope, maxlen, 0);
  83         if (ret < 0)
  84                 return log_msg_ret("fill", ret);
  85
  86         return 0;
  87 }
  88
  89 enum acpi_dev_status acpi_device_status(const struct udevice *dev)
  90 {
  91         return ACPI_DSTATUS_ALL_ON;
  92 }
  93
  94 /**
  95  * largeres_write_len_f() - Write a placeholder word value
  96  *
  97  * Write a forward length for a large resource (2 bytes)
  98  *
  99  * Return: pointer to the zero word (for fixing up later)
 100  */
 101 static void *largeres_write_len_f(struct acpi_ctx *ctx)
 102 {
 103         u8 *p = acpigen_get_current(ctx);
 104
 105         acpigen_emit_word(ctx, 0);
 106
 107         return p;
 108 }
 109
 110 /**
 111  * largeres_fill_from_len() - Fill in a length value
 112  *
 113  * This calculated the number of bytes since the provided @start and writes it
 114  * to @ptr, which was previous returned by largeres_write_len_f().
 115  *
 116  * @ptr: Word to update
 117  * @start: Start address to count from to calculated the length
 118  */
 119 static void largeres_fill_from_len(struct acpi_ctx *ctx, char *ptr, u8 *start)
 120 {
 121         u16 len = acpigen_get_current(ctx) - start;
 122
 123         ptr[0] = len & 0xff;
 124         ptr[1] = (len >> 8) & 0xff;
 125 }
 126
 127 /**
 128  * largeres_fill_len() - Fill in a length value, excluding the length itself
 129  *
 130  * Fill in the length field with the value calculated from after the 16bit
 131  * field to acpigen current. This is useful since the length value does not
 132  * include the length field itself.
 133  *
 134  * This calls acpi_device_largeres_fill_len() passing @ptr + 2 as @start
 135  *
 136  * @ptr: Word to update.
 137  */
 138 static void largeres_fill_len(struct acpi_ctx *ctx, void *ptr)
 139 {
 140         largeres_fill_from_len(ctx, ptr, ptr + sizeof(u16));
 141 }
 142
 143 /* ACPI 6.3 section 6.4.3.6: Extended Interrupt Descriptor */
 144 static int acpi_device_write_interrupt(struct acpi_ctx *ctx,
 145                                        const struct acpi_irq *irq)
 146 {
 147         void *desc_length;
 148         u8 flags;
 149
 150         if (!irq->pin)
 151                 return -ENOENT;
 152
 153         /* This is supported by GpioInt() but not Interrupt() */
 154         if (irq->polarity == ACPI_IRQ_ACTIVE_BOTH)
 155                 return -EINVAL;
 156
 157         /* Byte 0: Descriptor Type */
 158         acpigen_emit_byte(ctx, ACPI_DESCRIPTOR_INTERRUPT);
 159
 160         /* Byte 1-2: Length (filled in later) */
 161         desc_length = largeres_write_len_f(ctx);
 162
 163         /*
 164          * Byte 3: Flags
 165          *  [7:5]: Reserved
 166          *    [4]: Wake     (0=NO_WAKE   1=WAKE)
 167          *    [3]: Sharing  (0=EXCLUSIVE 1=SHARED)
 168          *    [2]: Polarity (0=HIGH      1=LOW)
 169          *    [1]: Mode     (0=LEVEL     1=EDGE)
 170          *    [0]: Resource (0=PRODUCER  1=CONSUMER)
 171          */
 172         flags = BIT(0); /* ResourceConsumer */
 173         if (irq->mode == ACPI_IRQ_EDGE_TRIGGERED)
 174                 flags |= BIT(1);
 175         if (irq->polarity == ACPI_IRQ_ACTIVE_LOW)
 176                 flags |= BIT(2);
 177         if (irq->shared == ACPI_IRQ_SHARED)
 178                 flags |= BIT(3);
 179         if (irq->wake == ACPI_IRQ_WAKE)
 180                 flags |= BIT(4);
 181         acpigen_emit_byte(ctx, flags);
 182
 183         /* Byte 4: Interrupt Table Entry Count */
 184         acpigen_emit_byte(ctx, 1);
 185
 186         /* Byte 5-8: Interrupt Number */
 187         acpigen_emit_dword(ctx, irq->pin);
 188
 189         /* Fill in Descriptor Length (account for len word) */
 190         largeres_fill_len(ctx, desc_length);
 191
 192         return 0;
 193 }
 194
 195 int acpi_device_write_interrupt_irq(struct acpi_ctx *ctx,
 196                                     const struct irq *req_irq)
 197 {
 198         struct acpi_irq irq;
 199         int ret;
 200
 201         ret = irq_get_acpi(req_irq, &irq);
 202         if (ret)
 203                 return log_msg_ret("get", ret);
 204         ret = acpi_device_write_interrupt(ctx, &irq);
 205         if (ret)
 206                 return log_msg_ret("write", ret);
 207
 208         return irq.pin;
 209 }
 210
 211 /* ACPI 6.3 section 6.4.3.8.1 - GPIO Interrupt or I/O */
 212 int acpi_device_write_gpio(struct acpi_ctx *ctx, const struct acpi_gpio *gpio)
 213 {
 214         void *start, *desc_length;
 215         void *pin_table_offset, *vendor_data_offset, *resource_offset;
 216         u16 flags = 0;
 217         int pin;
 218
 219         if (gpio->type > ACPI_GPIO_TYPE_IO)
 220                 return -EINVAL;
 221
 222         start = acpigen_get_current(ctx);
 223
 224         /* Byte 0: Descriptor Type */
 225         acpigen_emit_byte(ctx, ACPI_DESCRIPTOR_GPIO);
 226
 227         /* Byte 1-2: Length (fill in later) */
 228         desc_length = largeres_write_len_f(ctx);
 229
 230         /* Byte 3: Revision ID */
 231         acpigen_emit_byte(ctx, ACPI_GPIO_REVISION_ID);
 232
 233         /* Byte 4: GpioIo or GpioInt */
 234         acpigen_emit_byte(ctx, gpio->type);
 235
 236         /*
 237          * Byte 5-6: General Flags
 238          *   [15:1]: 0 => Reserved
 239          *      [0]: 1 => ResourceConsumer
 240          */
 241         acpigen_emit_word(ctx, 1 << 0);
 242
 243         switch (gpio->type) {
 244         case ACPI_GPIO_TYPE_INTERRUPT:
 245                 /*
 246                  * Byte 7-8: GPIO Interrupt Flags
 247                  *   [15:5]: 0 => Reserved
 248                  *      [4]: Wake     (0=NO_WAKE   1=WAKE)
 249                  *      [3]: Sharing  (0=EXCLUSIVE 1=SHARED)
 250                  *    [2:1]: Polarity (0=HIGH      1=LOW     2=BOTH)
 251                  *      [0]: Mode     (0=LEVEL     1=EDGE)
 252                  */
 253                 if (gpio->irq.mode == ACPI_IRQ_EDGE_TRIGGERED)
 254                         flags |= 1 << 0;
 255                 if (gpio->irq.shared == ACPI_IRQ_SHARED)
 256                         flags |= 1 << 3;
 257                 if (gpio->irq.wake == ACPI_IRQ_WAKE)
 258                         flags |= 1 << 4;
 259
 260                 switch (gpio->irq.polarity) {
 261                 case ACPI_IRQ_ACTIVE_HIGH:
 262                         flags |= 0 << 1;
 263                         break;
 264                 case ACPI_IRQ_ACTIVE_LOW:
 265                         flags |= 1 << 1;
 266                         break;
 267                 case ACPI_IRQ_ACTIVE_BOTH:
 268                         flags |= 2 << 1;
 269                         break;
 270                 }
 271                 break;
 272
 273         case ACPI_GPIO_TYPE_IO:
 274                 /*
 275                  * Byte 7-8: GPIO IO Flags
 276                  *   [15:4]: 0 => Reserved
 277                  *      [3]: Sharing  (0=EXCLUSIVE 1=SHARED)
 278                  *      [2]: 0 => Reserved
 279                  *    [1:0]: IO Restriction
 280                  *           0 => IoRestrictionNone
 281                  *           1 => IoRestrictionInputOnly
 282                  *           2 => IoRestrictionOutputOnly
 283                  *           3 => IoRestrictionNoneAndPreserve
 284                  */
 285                 flags |= gpio->io_restrict & 3;
 286                 if (gpio->io_shared)
 287                         flags |= 1 << 3;
 288                 break;
 289         }
 290         acpigen_emit_word(ctx, flags);
 291
 292         /*
 293          * Byte 9: Pin Configuration
 294          *  0x01 => Default (no configuration applied)
 295          *  0x02 => Pull-up
 296          *  0x03 => Pull-down
 297          *  0x04-0x7F => Reserved
 298          *  0x80-0xff => Vendor defined
 299          */
 300         acpigen_emit_byte(ctx, gpio->pull);
 301
 302         /* Byte 10-11: Output Drive Strength in 1/100 mA */
 303         acpigen_emit_word(ctx, gpio->output_drive_strength);
 304
 305         /* Byte 12-13: Debounce Timeout in 1/100 ms */
 306         acpigen_emit_word(ctx, gpio->interrupt_debounce_timeout);
 307
 308         /* Byte 14-15: Pin Table Offset, relative to start */
 309         pin_table_offset = largeres_write_len_f(ctx);
 310
 311         /* Byte 16: Reserved */
 312         acpigen_emit_byte(ctx, 0);
 313
 314         /* Byte 17-18: Resource Source Name Offset, relative to start */
 315         resource_offset = largeres_write_len_f(ctx);
 316
 317         /* Byte 19-20: Vendor Data Offset, relative to start */
 318         vendor_data_offset = largeres_write_len_f(ctx);
 319
 320         /* Byte 21-22: Vendor Data Length */
 321         acpigen_emit_word(ctx, 0);
 322
 323         /* Fill in Pin Table Offset */
 324         largeres_fill_from_len(ctx, pin_table_offset, start);
 325
 326         /* Pin Table, one word for each pin */
 327         for (pin = 0; pin < gpio->pin_count; pin++)
 328                 acpigen_emit_word(ctx, gpio->pins[pin]);
 329
 330         /* Fill in Resource Source Name Offset */
 331         largeres_fill_from_len(ctx, resource_offset, start);
 332
 333         /* Resource Source Name String */
 334         acpigen_emit_string(ctx, gpio->resource);
 335
 336         /* Fill in Vendor Data Offset */
 337         largeres_fill_from_len(ctx, vendor_data_offset, start);
 338
 339         /* Fill in GPIO Descriptor Length (account for len word) */
 340         largeres_fill_len(ctx, desc_length);
 341
 342         return gpio->pins[0];
 343 }
 344
 345 int acpi_device_write_gpio_desc(struct acpi_ctx *ctx,
 346                                 const struct gpio_desc *desc)
 347 {
 348         struct acpi_gpio gpio;
 349         int ret;
 350
 351         ret = gpio_get_acpi(desc, &gpio);
 352         if (ret)
 353                 return log_msg_ret("desc", ret);
 354         ret = acpi_device_write_gpio(ctx, &gpio);
 355         if (ret < 0)
 356                 return log_msg_ret("gpio", ret);
 357
 358         return ret;
 359 }
 360
 361 int acpi_device_write_interrupt_or_gpio(struct acpi_ctx *ctx,
 362                                         struct udevice *dev, const char *prop)
 363 {
 364         struct irq req_irq;
 365         int pin;
 366         int ret;
 367
 368         ret = irq_get_by_index(dev, 0, &req_irq);
 369         if (!ret) {
 370                 ret = acpi_device_write_interrupt_irq(ctx, &req_irq);
 371                 if (ret < 0)
 372                         return log_msg_ret("irq", ret);
 373                 pin = ret;
 374         } else {
 375                 struct gpio_desc req_gpio;
 376
 377                 ret = gpio_request_by_name(dev, prop, 0, &req_gpio,
 378                                            GPIOD_IS_IN);
 379                 if (ret)
 380                         return log_msg_ret("no gpio", ret);
 381                 ret = acpi_device_write_gpio_desc(ctx, &req_gpio);
 382                 if (ret < 0)
 383                         return log_msg_ret("gpio", ret);
 384                 pin = ret;
 385         }
 386
 387         return pin;
 388 }
 389
 390 /* PowerResource() with Enable and/or Reset control */
 391 int acpi_device_add_power_res(struct acpi_ctx *ctx, u32 tx_state_val,
 392                               const char *dw0_read, const char *dw0_write,
 393                               const struct gpio_desc *reset_gpio,
 394                               uint reset_delay_ms, uint reset_off_delay_ms,
 395                               const struct gpio_desc *enable_gpio,
 396                               uint enable_delay_ms, uint enable_off_delay_ms,
 397                               const struct gpio_desc *stop_gpio,
 398                               uint stop_delay_ms, uint stop_off_delay_ms)
 399 {
 400         static const char *const power_res_dev_states[] = { "_PR0", "_PR3" };
 401         struct acpi_gpio reset, enable, stop;
 402         bool has_reset, has_enable, has_stop;
 403         int ret;
 404
 405         gpio_get_acpi(reset_gpio, &reset);
 406         gpio_get_acpi(enable_gpio, &enable);
 407         gpio_get_acpi(stop_gpio, &stop);
 408         has_reset = reset.pins[0];
 409         has_enable = enable.pins[0];
 410         has_stop = stop.pins[0];
 411
 412         if (!has_reset && !has_enable && !has_stop)
 413                 return -EINVAL;
 414
 415         /* PowerResource (PRIC, 0, 0) */
 416         acpigen_write_power_res(ctx, "PRIC", 0, 0, power_res_dev_states,
 417                                 ARRAY_SIZE(power_res_dev_states));
 418
 419         /* Method (_STA, 0, NotSerialized) { Return (0x1) } */
 420         acpigen_write_sta(ctx, 0x1);
 421
 422         /* Method (_ON, 0, Serialized) */
 423         acpigen_write_method_serialized(ctx, "_ON", 0);
 424         if (has_reset) {
 425                 ret = acpigen_set_enable_tx_gpio(ctx, tx_state_val, dw0_read,
 426                                                  dw0_write, &reset, true);
 427                 if (ret)
 428                         return log_msg_ret("reset1", ret);
 429         }
 430         if (has_enable) {
 431                 ret = acpigen_set_enable_tx_gpio(ctx, tx_state_val, dw0_read,
 432                                                  dw0_write, &enable, true);
 433                 if (ret)
 434                         return log_msg_ret("enable1", ret);
 435                 if (enable_delay_ms)
 436                         acpigen_write_sleep(ctx, enable_delay_ms);
 437         }
 438         if (has_reset) {
 439                 ret = acpigen_set_enable_tx_gpio(ctx, tx_state_val, dw0_read,
 440                                                  dw0_write, &reset, false);
 441                 if (ret)
 442                         return log_msg_ret("reset2", ret);
 443                 if (reset_delay_ms)
 444                         acpigen_write_sleep(ctx, reset_delay_ms);
 445         }
 446         if (has_stop) {
 447                 ret = acpigen_set_enable_tx_gpio(ctx, tx_state_val, dw0_read,
 448                                                  dw0_write, &stop, false);
 449                 if (ret)
 450                         return log_msg_ret("stop1", ret);
 451                 if (stop_delay_ms)
 452                         acpigen_write_sleep(ctx, stop_delay_ms);
 453         }
 454         acpigen_pop_len(ctx);           /* _ON method */
 455
 456         /* Method (_OFF, 0, Serialized) */
 457         acpigen_write_method_serialized(ctx, "_OFF", 0);
 458         if (has_stop) {
 459                 ret = acpigen_set_enable_tx_gpio(ctx, tx_state_val, dw0_read,
 460                                                  dw0_write, &stop, true);
 461                 if (ret)
 462                         return log_msg_ret("stop2", ret);
 463                 if (stop_off_delay_ms)
 464                         acpigen_write_sleep(ctx, stop_off_delay_ms);
 465         }
 466         if (has_reset) {
 467                 ret = acpigen_set_enable_tx_gpio(ctx, tx_state_val, dw0_read,
 468                                                  dw0_write, &reset, true);
 469                 if (ret)
 470                         return log_msg_ret("reset3", ret);
 471                 if (reset_off_delay_ms)
 472                         acpigen_write_sleep(ctx, reset_off_delay_ms);
 473         }
 474         if (has_enable) {
 475                 ret = acpigen_set_enable_tx_gpio(ctx, tx_state_val, dw0_read,
 476                                                  dw0_write, &enable, false);
 477                 if (ret)
 478                         return log_msg_ret("enable2", ret);
 479                 if (enable_off_delay_ms)
 480                         acpigen_write_sleep(ctx, enable_off_delay_ms);
 481         }
 482         acpigen_pop_len(ctx);           /* _OFF method */
 483
 484         acpigen_pop_len(ctx);           /* PowerResource PRIC */
 485
 486         return 0;
 487 }
 488
 489 int acpi_device_write_dsm_i2c_hid(struct acpi_ctx *ctx,
 490                                   int hid_desc_reg_offset)
 491 {
 492         int ret;
 493
 494         acpigen_write_dsm_start(ctx);
 495         ret = acpigen_write_dsm_uuid_start(ctx, ACPI_DSM_I2C_HID_UUID);
 496         if (ret)
 497                 return log_ret(ret);
 498
 499         acpigen_write_dsm_uuid_start_cond(ctx, 0);
 500         /* ToInteger (Arg1, Local2) */
 501         acpigen_write_to_integer(ctx, ARG1_OP, LOCAL2_OP);
 502         /* If (LEqual (Local2, 0x0)) */
 503         acpigen_write_if_lequal_op_int(ctx, LOCAL2_OP, 0x0);
 504         /*   Return (Buffer (One) { 0x1f }) */
 505         acpigen_write_return_singleton_buffer(ctx, 0x1f);
 506         acpigen_pop_len(ctx);   /* Pop : If */
 507         /* Else */
 508         acpigen_write_else(ctx);
 509         /*   If (LEqual (Local2, 0x1)) */
 510         acpigen_write_if_lequal_op_int(ctx, LOCAL2_OP, 0x1);
 511         /*     Return (Buffer (One) { 0x3f }) */
 512         acpigen_write_return_singleton_buffer(ctx, 0x3f);
 513         acpigen_pop_len(ctx);   /* Pop : If */
 514         /*   Else */
 515         acpigen_write_else(ctx);
 516         /*     Return (Buffer (One) { 0x0 }) */
 517         acpigen_write_return_singleton_buffer(ctx, 0x0);
 518         acpigen_pop_len(ctx);   /* Pop : Else */
 519         acpigen_pop_len(ctx);   /* Pop : Else */
 520         acpigen_write_dsm_uuid_end_cond(ctx);
 521
 522         acpigen_write_dsm_uuid_start_cond(ctx, 1);
 523         acpigen_write_return_byte(ctx, hid_desc_reg_offset);
 524         acpigen_write_dsm_uuid_end_cond(ctx);
 525
 526         acpigen_write_dsm_uuid_end(ctx);
 527         acpigen_write_dsm_end(ctx);
 528
 529         return 0;
 530 }
 531
 532 /* ACPI 6.3 section 6.4.3.8.2.1 - I2cSerialBusV2() */
 533 static void acpi_device_write_i2c(struct acpi_ctx *ctx,
 534                                   const struct acpi_i2c *i2c)
 535 {
 536         void *desc_length, *type_length;
 537
 538         /* Byte 0: Descriptor Type */
 539         acpigen_emit_byte(ctx, ACPI_DESCRIPTOR_SERIAL_BUS);
 540
 541         /* Byte 1+2: Length (filled in later) */
 542         desc_length = largeres_write_len_f(ctx);
 543
 544         /* Byte 3: Revision ID */
 545         acpigen_emit_byte(ctx, ACPI_I2C_SERIAL_BUS_REVISION_ID);
 546
 547         /* Byte 4: Resource Source Index is Reserved */
 548         acpigen_emit_byte(ctx, 0);
 549
 550         /* Byte 5: Serial Bus Type is I2C */
 551         acpigen_emit_byte(ctx, ACPI_SERIAL_BUS_TYPE_I2C);
 552
 553         /*
 554          * Byte 6: Flags
 555          *  [7:2]: 0 => Reserved
 556          *    [1]: 1 => ResourceConsumer
 557          *    [0]: 0 => ControllerInitiated
 558          */
 559         acpigen_emit_byte(ctx, 1 << 1);
 560
 561         /*
 562          * Byte 7-8: Type Specific Flags
 563          *   [15:1]: 0 => Reserved
 564          *      [0]: 0 => 7bit, 1 => 10bit
 565          */
 566         acpigen_emit_word(ctx, i2c->mode_10bit);
 567
 568         /* Byte 9: Type Specific Revision ID */
 569         acpigen_emit_byte(ctx, ACPI_I2C_TYPE_SPECIFIC_REVISION_ID);
 570
 571         /* Byte 10-11: I2C Type Data Length */
 572         type_length = largeres_write_len_f(ctx);
 573
 574         /* Byte 12-15: I2C Bus Speed */
 575         acpigen_emit_dword(ctx, i2c->speed);
 576
 577         /* Byte 16-17: I2C Slave Address */
 578         acpigen_emit_word(ctx, i2c->address);
 579
 580         /* Fill in Type Data Length */
 581         largeres_fill_len(ctx, type_length);
 582
 583         /* Byte 18+: ResourceSource */
 584         acpigen_emit_string(ctx, i2c->resource);
 585
 586         /* Fill in I2C Descriptor Length */
 587         largeres_fill_len(ctx, desc_length);
 588 }
 589
 590 /**
 591  * acpi_device_set_i2c() - Set up an ACPI I2C struct from a device
 592  *
 593  * The value of @scope is not copied, but only referenced. This implies the
 594  * caller has to ensure it stays valid for the lifetime of @i2c.
 595  *
 596  * @dev: I2C device to convert
 597  * @i2c: Place to put the new structure
 598  * @scope: Scope of the I2C device (this is the controller path)
 599  * Return: chip address of device
 600  */
 601 static int acpi_device_set_i2c(const struct udevice *dev, struct acpi_i2c *i2c,
 602                                const char *scope)
 603 {
 604         struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
 605         struct udevice *bus = dev_get_parent(dev);
 606
 607         memset(i2c, '\0', sizeof(*i2c));
 608         i2c->address = chip->chip_addr;
 609         i2c->mode_10bit = 0;
 610
 611         /*
 612          * i2c_bus->speed_hz is set if this device is probed, but if not we
 613          * must use the device tree
 614          */
 615         i2c->speed = dev_read_u32_default(bus, "clock-frequency",
 616                                           I2C_SPEED_STANDARD_RATE);
 617         i2c->resource = scope;
 618
 619         return i2c->address;
 620 }
 621
 622 int acpi_device_write_i2c_dev(struct acpi_ctx *ctx, const struct udevice *dev)
 623 {
 624         char scope[ACPI_PATH_MAX];
 625         struct acpi_i2c i2c;
 626         int ret;
 627
 628         ret = acpi_device_scope(dev, scope, sizeof(scope));
 629         if (ret)
 630                 return log_msg_ret("scope", ret);
 631         ret = acpi_device_set_i2c(dev, &i2c, scope);
 632         if (ret < 0)
 633                 return log_msg_ret("set", ret);
 634         acpi_device_write_i2c(ctx, &i2c);
 635
 636         return ret;
 637 }
 638
 639 #ifdef CONFIG_SPI
 640 /* ACPI 6.1 section 6.4.3.8.2.2 - SpiSerialBus() */
 641 static void acpi_device_write_spi(struct acpi_ctx *ctx, const struct acpi_spi *spi)
 642 {
 643         void *desc_length, *type_length;
 644         u16 flags = 0;
 645
 646         /* Byte 0: Descriptor Type */
 647         acpigen_emit_byte(ctx, ACPI_DESCRIPTOR_SERIAL_BUS);
 648
 649         /* Byte 1+2: Length (filled in later) */
 650         desc_length = largeres_write_len_f(ctx);
 651
 652         /* Byte 3: Revision ID */
 653         acpigen_emit_byte(ctx, ACPI_SPI_SERIAL_BUS_REVISION_ID);
 654
 655         /* Byte 4: Resource Source Index is Reserved */
 656         acpigen_emit_byte(ctx, 0);
 657
 658         /* Byte 5: Serial Bus Type is SPI */
 659         acpigen_emit_byte(ctx, ACPI_SERIAL_BUS_TYPE_SPI);
 660
 661         /*
 662          * Byte 6: Flags
 663          *  [7:2]: 0 => Reserved
 664          *    [1]: 1 => ResourceConsumer
 665          *    [0]: 0 => ControllerInitiated
 666          */
 667         acpigen_emit_byte(ctx, BIT(1));
 668
 669         /*
 670          * Byte 7-8: Type Specific Flags
 671          *   [15:2]: 0 => Reserveda
 672          *      [1]: 0 => ActiveLow, 1 => ActiveHigh
 673          *      [0]: 0 => FourWire, 1 => ThreeWire
 674          */
 675         if (spi->wire_mode == SPI_3_WIRE_MODE)
 676                 flags |= BIT(0);
 677         if (spi->device_select_polarity == SPI_POLARITY_HIGH)
 678                 flags |= BIT(1);
 679         acpigen_emit_word(ctx, flags);
 680
 681         /* Byte 9: Type Specific Revision ID */
 682         acpigen_emit_byte(ctx, ACPI_SPI_TYPE_SPECIFIC_REVISION_ID);
 683
 684         /* Byte 10-11: SPI Type Data Length */
 685         type_length = largeres_write_len_f(ctx);
 686
 687         /* Byte 12-15: Connection Speed */
 688         acpigen_emit_dword(ctx, spi->speed);
 689
 690         /* Byte 16: Data Bit Length */
 691         acpigen_emit_byte(ctx, spi->data_bit_length);
 692
 693         /* Byte 17: Clock Phase */
 694         acpigen_emit_byte(ctx, spi->clock_phase);
 695
 696         /* Byte 18: Clock Polarity */
 697         acpigen_emit_byte(ctx, spi->clock_polarity);
 698
 699         /* Byte 19-20: Device Selection */
 700         acpigen_emit_word(ctx, spi->device_select);
 701
 702         /* Fill in Type Data Length */
 703         largeres_fill_len(ctx, type_length);
 704
 705         /* Byte 21+: ResourceSource String */
 706         acpigen_emit_string(ctx, spi->resource);
 707
 708         /* Fill in SPI Descriptor Length */
 709         largeres_fill_len(ctx, desc_length);
 710 }
 711
 712 /**
 713  * acpi_device_set_spi() - Set up an ACPI SPI struct from a device
 714  *
 715  * The value of @scope is not copied, but only referenced. This implies the
 716  * caller has to ensure it stays valid for the lifetime of @spi.
 717  *
 718  * @dev: SPI device to convert
 719  * @spi: Place to put the new structure
 720  * @scope: Scope of the SPI device (this is the controller path)
 721  * Return: 0 (always)
 722  */
 723 static int acpi_device_set_spi(const struct udevice *dev, struct acpi_spi *spi,
 724                                const char *scope)
 725 {
 726         struct dm_spi_slave_plat *plat;
 727         struct spi_slave *slave = dev_get_parent_priv(dev);
 728
 729         plat = dev_get_parent_plat(slave->dev);
 730         memset(spi, '\0', sizeof(*spi));
 731         spi->device_select = plat->cs[0];
 732         spi->device_select_polarity = SPI_POLARITY_LOW;
 733         spi->wire_mode = SPI_4_WIRE_MODE;
 734         spi->speed = plat->max_hz;
 735         spi->data_bit_length = slave->wordlen;
 736         spi->clock_phase = plat->mode & SPI_CPHA ?
 737                  SPI_CLOCK_PHASE_SECOND : SPI_CLOCK_PHASE_FIRST;
 738         spi->clock_polarity = plat->mode & SPI_CPOL ?
 739                  SPI_POLARITY_HIGH : SPI_POLARITY_LOW;
 740         spi->resource = scope;
 741
 742         return 0;
 743 }
 744
 745 int acpi_device_write_spi_dev(struct acpi_ctx *ctx, const struct udevice *dev)
 746 {
 747         char scope[ACPI_PATH_MAX];
 748         struct acpi_spi spi;
 749         int ret;
 750
 751         ret = acpi_device_scope(dev, scope, sizeof(scope));
 752         if (ret)
 753                 return log_msg_ret("scope", ret);
 754         ret = acpi_device_set_spi(dev, &spi, scope);
 755         if (ret)
 756                 return log_msg_ret("set", ret);
 757         acpi_device_write_spi(ctx, &spi);
 758
 759         return 0;
 760 }
 761 #endif /* CONFIG_SPI */
 762
 763 static const char *acpi_name_from_id(enum uclass_id id)
 764 {
 765         switch (id) {
 766         case UCLASS_USB_HUB:
 767                 /* Root Hub */
 768                 return "RHUB";
 769         /* DSDT: acpi/northbridge.asl */
 770         case UCLASS_NORTHBRIDGE:
 771                 return "MCHC";
 772         /* DSDT: acpi/lpc.asl */
 773         case UCLASS_LPC:
 774                 return "LPCB";
 775         /* DSDT: acpi/xhci.asl */
 776         case UCLASS_USB:
 777                 /* This only supports USB3.0 controllers at present */
 778                 return "XHCI";
 779         case UCLASS_PWM:
 780                 return "PWM";
 781         default:
 782                 return NULL;
 783         }
 784 }
 785
 786 /* If you change this function, add test cases to dm_test_acpi_get_name() */
 787 int acpi_device_infer_name(const struct udevice *dev, char *out_name)
 788 {
 789         enum uclass_id parent_id = UCLASS_INVALID;
 790         enum uclass_id id;
 791         const char *name = NULL;
 792
 793         id = device_get_uclass_id(dev);
 794         if (dev_get_parent(dev))
 795                 parent_id = device_get_uclass_id(dev_get_parent(dev));
 796
 797         if (id == UCLASS_SOUND)
 798                 name = "HDAS";
 799         else if (id == UCLASS_PCI)
 800                 name = "PCI0";
 801         else if (device_is_on_pci_bus(dev))
 802                 name = acpi_name_from_id(id);
 803         if (!name) {
 804                 switch (parent_id) {
 805                 case UCLASS_USB: {
 806                         struct usb_device *udev = dev_get_parent_priv(dev);
 807
 808                         sprintf(out_name, udev->speed >= USB_SPEED_SUPER ?
 809                                 "HS%02d" : "FS%02d", udev->portnr);
 810                         name = out_name;
 811                         break;
 812                 }
 813                 default:
 814                         break;
 815                 }
 816         }
 817         if (!name) {
 818                 switch (id) {
 819                 /* DSDT: acpi/lpss.asl */
 820                 case UCLASS_SERIAL:
 821                         sprintf(out_name, "URT%d", dev_seq(dev));
 822                         name = out_name;
 823                         break;
 824                 case UCLASS_I2C:
 825                         sprintf(out_name, "I2C%d", dev_seq(dev));
 826                         name = out_name;
 827                         break;
 828                 case UCLASS_SPI:
 829                         sprintf(out_name, "SPI%d", dev_seq(dev));
 830                         name = out_name;
 831                         break;
 832                 default:
 833                         break;
 834                 }
 835         }
 836         if (!name) {
 837                 log_warning("No name for device '%s'\n", dev->name);
 838                 return -ENOENT;
 839         }
 840         if (name != out_name)
 841                 acpi_copy_name(out_name, name);
 842
 843         return 0;
 844 }