src/arch/x86/boot/acpigen.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2009 Rudolf Marek <r.marek@assembler.cz>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  */
  19
  20 /* how many nesting we support */
  21 #define ACPIGEN_LENSTACK_SIZE 10
  22
  23 /* if you need to change this, change the acpigen_write_f and
  24    acpigen_patch_len */
  25
  26 #define ACPIGEN_MAXLEN 0xfff
  27
  28 #include <string.h>
  29 #include <arch/acpigen.h>
  30 #include <console/console.h>
  31 #include <device/device.h>
  32
  33 static char *gencurrent;
  34
  35 char *len_stack[ACPIGEN_LENSTACK_SIZE];
  36 int ltop = 0;
  37
  38 static int acpigen_write_len_f(void)
  39 {
  40         ASSERT(ltop < (ACPIGEN_LENSTACK_SIZE - 1))
  41             len_stack[ltop++] = gencurrent;
  42         acpigen_emit_byte(0);
  43         acpigen_emit_byte(0);
  44         return 2;
  45 }
  46
  47 void acpigen_patch_len(int len)
  48 {
  49         ASSERT(len <= ACPIGEN_MAXLEN)
  50             ASSERT(ltop > 0)
  51         char *p = len_stack[--ltop];
  52         /* generate store length for 0xfff max */
  53         p[0] = (0x40 | (len & 0xf));
  54         p[1] = (len >> 4 & 0xff);
  55
  56 }
  57
  58 void acpigen_set_current(char *curr)
  59 {
  60         gencurrent = curr;
  61 }
  62
  63 char *acpigen_get_current(void)
  64 {
  65         return gencurrent;
  66 }
  67
  68 int acpigen_emit_byte(unsigned char b)
  69 {
  70         (*gencurrent++) = b;
  71         return 1;
  72 }
  73
  74 int acpigen_write_package(int nr_el)
  75 {
  76         int len;
  77         /* package op */
  78         acpigen_emit_byte(0x12);
  79         len = acpigen_write_len_f();
  80         acpigen_emit_byte(nr_el);
  81         return len + 2;
  82 }
  83
  84 int acpigen_write_byte(unsigned int data)
  85 {
  86         /* byte op */
  87         acpigen_emit_byte(0xa);
  88         acpigen_emit_byte(data & 0xff);
  89         return 2;
  90 }
  91
  92 int acpigen_write_dword(unsigned int data)
  93 {
  94         /* dword op */
  95         acpigen_emit_byte(0xc);
  96         acpigen_emit_byte(data & 0xff);
  97         acpigen_emit_byte((data >> 8) & 0xff);
  98         acpigen_emit_byte((data >> 16) & 0xff);
  99         acpigen_emit_byte((data >> 24) & 0xff);
 100         return 5;
 101 }
 102
 103 int acpigen_write_qword(uint64_t data)
 104 {
 105         /* qword op */
 106         acpigen_emit_byte(0xe);
 107         acpigen_emit_byte(data & 0xff);
 108         acpigen_emit_byte((data >> 8) & 0xff);
 109         acpigen_emit_byte((data >> 16) & 0xff);
 110         acpigen_emit_byte((data >> 24) & 0xff);
 111         acpigen_emit_byte((data >> 32) & 0xff);
 112         acpigen_emit_byte((data >> 40) & 0xff);
 113         acpigen_emit_byte((data >> 48) & 0xff);
 114         acpigen_emit_byte((data >> 56) & 0xff);
 115         return 9;
 116 }
 117
 118 int acpigen_write_name_byte(const char *name, uint8_t val)
 119 {
 120         int len;
 121         len = acpigen_write_name(name);
 122         len += acpigen_write_byte(val);
 123         return len;
 124 }
 125
 126 int acpigen_write_name_dword(const char *name, uint32_t val)
 127 {
 128         int len;
 129         len = acpigen_write_name(name);
 130         len += acpigen_write_dword(val);
 131         return len;
 132 }
 133
 134 int acpigen_write_name_qword(const char *name, uint64_t val)
 135 {
 136         int len;
 137         len = acpigen_write_name(name);
 138         len += acpigen_write_qword(val);
 139         return len;
 140 }
 141
 142 int acpigen_emit_stream(const char *data, int size)
 143 {
 144         int i;
 145         for (i = 0; i < size; i++) {
 146                 acpigen_emit_byte(data[i]);
 147         }
 148         return size;
 149 }
 150
 151 /* The NameString are bit tricky, each element can be 4 chars, if
 152    less its padded with underscore. Check 18.2.2 and 18.4
 153    and 5.3 of ACPI specs 3.0 for details
 154 */
 155
 156 static int acpigen_emit_simple_namestring(const char *name) {
 157         int i, len = 0;
 158         char ud[] = "____";
 159         for (i = 0; i < 4; i++) {
 160                 if ((name[i] == '\0') || (name[i] == '.')) {
 161                         len += acpigen_emit_stream(ud, 4 - i);
 162                         break;
 163                 } else {
 164                         len += acpigen_emit_byte(name[i]);
 165                 }
 166         }
 167         return len;
 168 }
 169
 170 static int acpigen_emit_double_namestring(const char *name, int dotpos) {
 171         int len = 0;
 172         /* mark dual name prefix */
 173         len += acpigen_emit_byte(0x2e);
 174         len += acpigen_emit_simple_namestring(name);
 175         len += acpigen_emit_simple_namestring(&name[dotpos + 1]);
 176         return len;
 177 }
 178
 179 static int acpigen_emit_multi_namestring(const char *name) {
 180         int len = 0, count = 0;
 181         unsigned char *pathlen;
 182         /* mark multi name prefix */
 183         len += acpigen_emit_byte(0x2f);
 184         len += acpigen_emit_byte(0x0);
 185         pathlen = ((unsigned char *) acpigen_get_current()) - 1;
 186
 187         while (name[0] != '\0') {
 188                 len += acpigen_emit_simple_namestring(name);
 189                 /* find end or next entity */
 190                 while ((name[0] != '.') && (name[0] != '\0'))
 191                         name++;
 192                 /* forward to next */
 193                 if (name[0] == '.')
 194                         name++;
 195                 count++;
 196         }
 197
 198         pathlen[0] = count;
 199         return len;
 200 }
 201
 202
 203 int acpigen_emit_namestring(const char *namepath) {
 204         int dotcount = 0, i;
 205         int dotpos = 0;
 206         int len = 0;
 207
 208         /* we can start with a \ */
 209         if (namepath[0] == '\\') {
 210                 len += acpigen_emit_byte('\\');
 211                 namepath++;
 212         }
 213
 214         /* and there can be any number of ^ */
 215         while (namepath[0] == '^') {
 216                 len += acpigen_emit_byte('^');
 217                 namepath++;
 218         }
 219
 220         ASSERT(namepath[0] != '\0');
 221
 222         i = 0;
 223         while (namepath[i] != '\0') {
 224                 if (namepath[i] == '.') {
 225                         dotcount++;
 226                         dotpos = i;
 227                 }
 228                 i++;
 229         }
 230
 231         if (dotcount == 0) {
 232                 len += acpigen_emit_simple_namestring(namepath);
 233         } else if (dotcount == 1) {
 234                 len += acpigen_emit_double_namestring(namepath, dotpos);
 235         } else {
 236                 len += acpigen_emit_multi_namestring(namepath);
 237         }
 238         return len;
 239 }
 240
 241 int acpigen_write_name(const char *name)
 242 {
 243         int len;
 244         /* name op */
 245         len = acpigen_emit_byte(0x8);
 246         return len + acpigen_emit_namestring(name);
 247 }
 248
 249 int acpigen_write_scope(const char *name)
 250 {
 251         int len;
 252         /* scope op */
 253         len = acpigen_emit_byte(0x10);
 254         len += acpigen_write_len_f();
 255         return len + acpigen_emit_namestring(name);
 256 }
 257
 258 int acpigen_write_processor(u8 cpuindex, u32 pblock_addr, u8 pblock_len)
 259 {
 260 /*
 261         Processor (\_PR.CPUcpuindex, cpuindex, pblock_addr, pblock_len)
 262         {
 263 */
 264         char pscope[16];
 265         int len;
 266         /* processor op */
 267         acpigen_emit_byte(0x5b);
 268         acpigen_emit_byte(0x83);
 269         len = acpigen_write_len_f();
 270
 271         sprintf(pscope, "\\_PR.CPU%x", (unsigned int) cpuindex);
 272         len += acpigen_emit_namestring(pscope);
 273         acpigen_emit_byte(cpuindex);
 274         acpigen_emit_byte(pblock_addr & 0xff);
 275         acpigen_emit_byte((pblock_addr >> 8) & 0xff);
 276         acpigen_emit_byte((pblock_addr >> 16) & 0xff);
 277         acpigen_emit_byte((pblock_addr >> 24) & 0xff);
 278         acpigen_emit_byte(pblock_len);
 279         return 6 + 2 + len;
 280 }
 281
 282 int acpigen_write_empty_PCT(void)
 283 {
 284 /*
 285     Name (_PCT, Package (0x02)
 286     {
 287         ResourceTemplate ()
 288         {
 289             Register (FFixedHW,
 290                 0x00,               // Bit Width
 291                 0x00,               // Bit Offset
 292                 0x0000000000000000, // Address
 293                 ,)
 294         },
 295
 296         ResourceTemplate ()
 297         {
 298             Register (FFixedHW,
 299                 0x00,               // Bit Width
 300                 0x00,               // Bit Offset
 301                 0x0000000000000000, // Address
 302                 ,)
 303         }
 304     })
 305 */
 306         static char stream[] = {
 307                 0x08, 0x5F, 0x50, 0x43, 0x54, 0x12, 0x2C,       /* 00000030    "0._PCT.," */
 308                 0x02, 0x11, 0x14, 0x0A, 0x11, 0x82, 0x0C, 0x00, /* 00000038    "........" */
 309                 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00000040    "........" */
 310                 0x00, 0x00, 0x00, 0x00, 0x79, 0x00, 0x11, 0x14, /* 00000048    "....y..." */
 311                 0x0A, 0x11, 0x82, 0x0C, 0x00, 0x7F, 0x00, 0x00, /* 00000050    "........" */
 312                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00000058    "........" */
 313                 0x00, 0x79, 0x00
 314         };
 315         return acpigen_emit_stream(stream, ARRAY_SIZE(stream));
 316 }
 317
 318 /* generates a func with max supported P states */
 319 int acpigen_write_PPC(u8 nr)
 320 {
 321 /*
 322     Method (_PPC, 0, NotSerialized)
 323     {
 324         Return (nr)
 325     }
 326 */
 327         int len;
 328         /* method op */
 329         acpigen_emit_byte(0x14);
 330         len = acpigen_write_len_f();
 331         len += acpigen_emit_namestring("_PPC");
 332         /* no fnarg */
 333         acpigen_emit_byte(0x00);
 334         /* return */
 335         acpigen_emit_byte(0xa4);
 336         /* arg */
 337         len += acpigen_write_byte(nr);
 338         /* add all single bytes */
 339         len += 3;
 340         acpigen_patch_len(len - 1);
 341         return len;
 342 }
 343
 344 int acpigen_write_PSS_package(u32 coreFreq, u32 power, u32 transLat,
 345                               u32 busmLat, u32 control, u32 status)
 346 {
 347         int len;
 348         len = acpigen_write_package(6);
 349         len += acpigen_write_dword(coreFreq);
 350         len += acpigen_write_dword(power);
 351         len += acpigen_write_dword(transLat);
 352         len += acpigen_write_dword(busmLat);
 353         len += acpigen_write_dword(control);
 354         len += acpigen_write_dword(status);
 355         //pkglen without the len opcode
 356         acpigen_patch_len(len - 1);
 357         return len;
 358 }
 359
 360 int acpigen_write_PSD_package(u32 domain, u32 numprocs, PSD_coord coordtype)
 361 {
 362         int len, lenh, lenp;
 363         lenh = acpigen_write_name("_PSD");
 364         lenp = acpigen_write_package(1);
 365         len = acpigen_write_package(5);
 366         len += acpigen_write_byte(5);   // 5 values
 367         len += acpigen_write_byte(0);   // revision 0
 368         len += acpigen_write_dword(domain);
 369         len += acpigen_write_dword(coordtype);
 370         len += acpigen_write_dword(numprocs);
 371         acpigen_patch_len(len - 1);
 372         len += lenp;
 373         acpigen_patch_len(len - 1);
 374         return len + lenh;
 375 }
 376
 377 static int acpigen_write_CST_package_entry(struct cst_entry *entry)
 378 {
 379         int len, len0;
 380         char *start, *end;
 381
 382         len0 = acpigen_write_package(4);
 383         len = acpigen_write_resourcetemplate_header();
 384         start = acpigen_get_current();
 385         acpigen_write_register(entry->type, entry->width, entry->offset, entry->addrsize, entry->address);
 386         end = acpigen_get_current();
 387         len += end-start;
 388         len += acpigen_write_resourcetemplate_footer(len);
 389         len += len0;
 390         len += acpigen_write_dword(entry->ctype);
 391         len += acpigen_write_dword(entry->latency);
 392         len += acpigen_write_dword(entry->power);
 393         acpigen_patch_len(len - 1);
 394         return len;
 395 }
 396
 397 int acpigen_write_CST_package(struct cst_entry *entry, int nentries)
 398 {
 399         int len, lenh, lenp, i;
 400         lenh = acpigen_write_name("_CST");
 401         lenp = acpigen_write_package(nentries+1);
 402         len = acpigen_write_dword(nentries);
 403
 404         for (i = 0; i < nentries; i++)
 405                 len += acpigen_write_CST_package_entry(entry + i);
 406
 407         len += lenp;
 408         acpigen_patch_len(len - 1);
 409         return len + lenh;
 410 }
 411
 412 int acpigen_write_mem32fixed(int readwrite, u32 base, u32 size)
 413 {
 414         /*
 415          * acpi 4.0 section 6.4.3.4: 32-Bit Fixed Memory Range Descriptor
 416          * Byte 0:
 417          *   Bit7  : 1 => big item
 418          *   Bit6-0: 0000110 (0x6) => 32-bit fixed memory
 419          */
 420         acpigen_emit_byte(0x86);
 421         /* Byte 1+2: length (0x0009) */
 422         acpigen_emit_byte(0x09);
 423         acpigen_emit_byte(0x00);
 424         /* bit1-7 are ignored */
 425         acpigen_emit_byte(readwrite ? 0x01 : 0x00);
 426         acpigen_emit_byte(base & 0xff);
 427         acpigen_emit_byte((base >> 8) & 0xff);
 428         acpigen_emit_byte((base >> 16) & 0xff);
 429         acpigen_emit_byte((base >> 24) & 0xff);
 430         acpigen_emit_byte(size & 0xff);
 431         acpigen_emit_byte((size >> 8) & 0xff);
 432         acpigen_emit_byte((size >> 16) & 0xff);
 433         acpigen_emit_byte((size >> 24) & 0xff);
 434         return 12;
 435 }
 436
 437 int acpigen_write_register(int type, int width, int offset, int addrsize, u64 address)
 438 {
 439         acpigen_emit_byte(0x82);
 440         /* Byte 1+2: length (0x000c) */
 441         acpigen_emit_byte(0x0c);
 442         acpigen_emit_byte(0x00);
 443         /* bit1-7 are ignored */
 444         acpigen_emit_byte(type); /* FFixedHW */
 445         acpigen_emit_byte(width); /* register width */
 446         acpigen_emit_byte(offset); /* register offset */
 447         acpigen_emit_byte(addrsize); /* register address size */
 448         acpigen_emit_byte(address & 0xff); /* register address 0-7 */
 449         acpigen_emit_byte((address >> 8) & 0xff); /* register address 8-15 */
 450         acpigen_emit_byte((address >> 16) & 0xff); /* register address 16-23 */
 451         acpigen_emit_byte((address >> 24) & 0xff); /* register address 24-31 */
 452         acpigen_emit_byte((address >> 32) & 0xff); /* register address 32-39 */
 453         acpigen_emit_byte((address >> 40) & 0xff); /* register address 40-47 */
 454         acpigen_emit_byte((address >> 48) & 0xff); /* register address 48-55 */
 455         acpigen_emit_byte((address >> 56) & 0xff); /* register address 56-63 */
 456         return 15;
 457 }
 458
 459 int acpigen_write_io16(u16 min, u16 max, u8 align, u8 len, u8 decode16)
 460 {
 461         /*
 462          * acpi 4.0 section 6.4.2.6: I/O Port Descriptor
 463          * Byte 0:
 464          *   Bit7  : 0 => small item
 465          *   Bit6-3: 1000 (0x8) => I/O port descriptor
 466          *   Bit2-0: 111 (0x7) => 7 Bytes long
 467          */
 468         acpigen_emit_byte(0x47);
 469         /* does the device decode all 16 or just 10 bits? */
 470         /* bit1-7 are ignored */
 471         acpigen_emit_byte(decode16 ? 0x01 : 0x00);
 472         /* minimum base address the device may be configured for */
 473         acpigen_emit_byte(min & 0xff);
 474         acpigen_emit_byte((min >> 8) & 0xff);
 475         /* maximum base address the device may be configured for */
 476         acpigen_emit_byte(max & 0xff);
 477         acpigen_emit_byte((max >> 8) & 0xff);
 478         /* alignment for min base */
 479         acpigen_emit_byte(align & 0xff);
 480         acpigen_emit_byte(len & 0xff);
 481         return 8;
 482 }
 483
 484 int acpigen_write_resourcetemplate_header(void)
 485 {
 486         int len;
 487         /*
 488          * A ResourceTemplate() is a Buffer() with a
 489          * (Byte|Word|DWord) containing the length, followed by one or more
 490          * resource items, terminated by the end tag
 491          * (small item 0xf, len 1)
 492          */
 493         len = acpigen_emit_byte(0x11); /* Buffer opcode */
 494         len += acpigen_write_len_f();
 495         len += acpigen_emit_byte(0x0b); /* Word opcode */
 496         len_stack[ltop++] = acpigen_get_current();
 497         len += acpigen_emit_byte(0x00);
 498         len += acpigen_emit_byte(0x00);
 499         return len;
 500 }
 501
 502 int acpigen_write_resourcetemplate_footer(int len)
 503 {
 504         char *p = len_stack[--ltop];
 505         /*
 506          * end tag (acpi 4.0 Section 6.4.2.8)
 507          * 0x79 <checksum>
 508          * 0x00 is treated as a good checksum according to the spec
 509          * and is what iasl generates.
 510          */
 511         len += acpigen_emit_byte(0x79);
 512         len += acpigen_emit_byte(0x00);
 513         /* patch len word */
 514         p[0] = (len-6) & 0xff;
 515         p[1] = ((len-6) >> 8) & 0xff;
 516         /* patch len field */
 517         acpigen_patch_len(len-1);
 518         return 2;
 519 }
 520
 521 static void acpigen_add_mainboard_rsvd_mem32(void *gp, struct device *dev,
 522                                                 struct resource *res)
 523 {
 524         acpigen_write_mem32fixed(0, res->base, res->size);
 525 }
 526
 527 static void acpigen_add_mainboard_rsvd_io(void *gp, struct device *dev,
 528                                                 struct resource *res)
 529 {
 530         resource_t base = res->base;
 531         resource_t size = res->size;
 532         while (size > 0) {
 533                 resource_t sz = size > 255 ? 255 : size;
 534                 acpigen_write_io16(base, base, 0, sz, 1);
 535                 size -= sz;
 536                 base += sz;
 537         }
 538 }
 539
 540 int acpigen_write_mainboard_resource_template(void)
 541 {
 542         int len;
 543         char *start;
 544         char *end;
 545         len = acpigen_write_resourcetemplate_header();
 546         start = acpigen_get_current();
 547
 548         /* Add reserved memory ranges */
 549         search_global_resources(
 550                 IORESOURCE_MEM | IORESOURCE_RESERVE,
 551                  IORESOURCE_MEM | IORESOURCE_RESERVE,
 552                 acpigen_add_mainboard_rsvd_mem32, 0);
 553
 554         /* Add reserved io ranges */
 555         search_global_resources(
 556                 IORESOURCE_IO | IORESOURCE_RESERVE,
 557                  IORESOURCE_IO | IORESOURCE_RESERVE,
 558                 acpigen_add_mainboard_rsvd_io, 0);
 559
 560         end = acpigen_get_current();
 561         len += end-start;
 562         len += acpigen_write_resourcetemplate_footer(len);
 563         return len;
 564 }
 565
 566 int acpigen_write_mainboard_resources(const char *scope, const char *name)
 567 {
 568         int len;
 569         len = acpigen_write_scope(scope);
 570         len += acpigen_write_name(name);
 571         len += acpigen_write_mainboard_resource_template();
 572         acpigen_patch_len(len - 1);
 573         return len;
 574 }