src/arch/i386/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 int acpigen_write_mem32fixed(int readwrite, u32 base, u32 size)
 378 {
 379         /*
 380          * acpi 4.0 section 6.4.3.4: 32-Bit Fixed Memory Range Descriptor
 381          * Byte 0:
 382          *   Bit7  : 1 => big item
 383          *   Bit6-0: 0000110 (0x6) => 32-bit fixed memory
 384          */
 385         acpigen_emit_byte(0x86);
 386         /* Byte 1+2: length (0x0009) */
 387         acpigen_emit_byte(0x09);
 388         acpigen_emit_byte(0x00);
 389         /* bit1-7 are ignored */
 390         acpigen_emit_byte(readwrite ? 0x01 : 0x00);
 391         acpigen_emit_byte(base & 0xff);
 392         acpigen_emit_byte((base >> 8) & 0xff);
 393         acpigen_emit_byte((base >> 16) & 0xff);
 394         acpigen_emit_byte((base >> 24) & 0xff);
 395         acpigen_emit_byte(size & 0xff);
 396         acpigen_emit_byte((size >> 8) & 0xff);
 397         acpigen_emit_byte((size >> 16) & 0xff);
 398         acpigen_emit_byte((size >> 24) & 0xff);
 399         return 12;
 400 }
 401
 402 int acpigen_write_io16(u16 min, u16 max, u8 align, u8 len, u8 decode16)
 403 {
 404         /*
 405          * acpi 4.0 section 6.4.2.6: I/O Port Descriptor
 406          * Byte 0:
 407          *   Bit7  : 0 => small item
 408          *   Bit6-3: 1000 (0x8) => I/O port descriptor
 409          *   Bit2-0: 111 (0x7) => 7 Bytes long
 410          */
 411         acpigen_emit_byte(0x47);
 412         /* does the device decode all 16 or just 10 bits? */
 413         /* bit1-7 are ignored */
 414         acpigen_emit_byte(decode16 ? 0x01 : 0x00);
 415         /* minimum base address the device may be configured for */
 416         acpigen_emit_byte(min & 0xff);
 417         acpigen_emit_byte((min >> 8) & 0xff);
 418         /* maximum base address the device may be configured for */
 419         acpigen_emit_byte(max & 0xff);
 420         acpigen_emit_byte((max >> 8) & 0xff);
 421         /* alignment for min base */
 422         acpigen_emit_byte(align & 0xff);
 423         acpigen_emit_byte(len & 0xff);
 424         return 8;
 425 }
 426
 427 int acpigen_write_resourcetemplate_header(void)
 428 {
 429         int len;
 430         /*
 431          * A ResourceTemplate() is a Buffer() with a
 432          * (Byte|Word|DWord) containing the length, followed by one or more
 433          * resource items, terminated by the end tag
 434          * (small item 0xf, len 1)
 435          */
 436         len = acpigen_emit_byte(0x11); /* Buffer opcode */
 437         len += acpigen_write_len_f();
 438         len += acpigen_emit_byte(0x0b); /* Word opcode */
 439         len_stack[ltop++] = acpigen_get_current();
 440         len += acpigen_emit_byte(0x00);
 441         len += acpigen_emit_byte(0x00);
 442         return len;
 443 }
 444
 445 int acpigen_write_resourcetemplate_footer(int len)
 446 {
 447         char *p = len_stack[--ltop];
 448         /*
 449          * end tag (acpi 4.0 Section 6.4.2.8)
 450          * 0x79 <checksum>
 451          * 0x00 is treated as a good checksum according to the spec
 452          * and is what iasl generates.
 453          */
 454         len += acpigen_emit_byte(0x79);
 455         len += acpigen_emit_byte(0x00);
 456         /* patch len word */
 457         p[0] = (len-6) & 0xff;
 458         p[1] = ((len-6) >> 8) & 0xff;
 459         /* patch len field */
 460         acpigen_patch_len(len-1);
 461         return 2;
 462 }
 463
 464 static void acpigen_add_mainboard_rsvd_mem32(void *gp, struct device *dev,
 465                                                 struct resource *res)
 466 {
 467         acpigen_write_mem32fixed(0, res->base, res->size);
 468 }
 469
 470 static void acpigen_add_mainboard_rsvd_io(void *gp, struct device *dev,
 471                                                 struct resource *res)
 472 {
 473         resource_t base = res->base;
 474         resource_t size = res->size;
 475         while (size > 0) {
 476                 resource_t sz = size > 255 ? 255 : size;
 477                 acpigen_write_io16(base, base, 0, sz, 1);
 478                 size -= sz;
 479                 base += sz;
 480         }
 481 }
 482
 483 int acpigen_write_mainboard_resource_template(void)
 484 {
 485         int len;
 486         char *start;
 487         char *end;
 488         len = acpigen_write_resourcetemplate_header();
 489         start = acpigen_get_current();
 490
 491         /* Add reserved memory ranges */
 492         search_global_resources(
 493                 IORESOURCE_MEM | IORESOURCE_RESERVE,
 494                  IORESOURCE_MEM | IORESOURCE_RESERVE,
 495                 acpigen_add_mainboard_rsvd_mem32, 0);
 496
 497         /* Add reserved io ranges */
 498         search_global_resources(
 499                 IORESOURCE_IO | IORESOURCE_RESERVE,
 500                  IORESOURCE_IO | IORESOURCE_RESERVE,
 501                 acpigen_add_mainboard_rsvd_io, 0);
 502
 503         end = acpigen_get_current();
 504         len += end-start;
 505         len += acpigen_write_resourcetemplate_footer(len);
 506         return len;
 507 }
 508
 509 int acpigen_write_mainboard_resources(const char *scope, const char *name)
 510 {
 511         int len;
 512         len = acpigen_write_scope(scope);
 513         len += acpigen_write_name(name);
 514         len += acpigen_write_mainboard_resource_template();
 515         acpigen_patch_len(len - 1);
 516         return len;
 517 }