blob: 976f4dbb9affed2a4b8ac596eec063f06cc992cb [file] [log] [blame]
Simon Glass61cc9332020-07-07 13:11:42 -06001/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Core ACPI (Advanced Configuration and Power Interface) support
4 *
5 * Copyright 2019 Google LLC
6 *
7 * Modified from coreboot file acpigen.h
8 */
9
10#ifndef __ACPI_ACPIGEN_H
11#define __ACPI_ACPIGEN_H
12
Simon Glass350c7f52020-09-22 12:45:13 -060013#include <acpi/acpi_table.h>
Simon Glass61cc9332020-07-07 13:11:42 -060014#include <linux/types.h>
15
Simon Glass350c7f52020-09-22 12:45:13 -060016struct acpi_cstate;
Simon Glass61cc9332020-07-07 13:11:42 -060017struct acpi_ctx;
Simon Glassd7d631d2020-07-07 21:32:11 -060018struct acpi_gen_regaddr;
Simon Glassf8054dd2020-07-07 13:12:01 -060019struct acpi_gpio;
Simon Glass61cc9332020-07-07 13:11:42 -060020
Simon Glass7e148f22020-07-07 13:11:50 -060021/* Top 4 bits of the value used to indicate a three-byte length value */
22#define ACPI_PKG_LEN_3_BYTES 0x80
23
Simon Glass9c70e7e2020-07-07 13:11:59 -060024#define ACPI_METHOD_NARGS_MASK 0x7
25#define ACPI_METHOD_SERIALIZED_MASK BIT(3)
26
Simon Glassd7d631d2020-07-07 21:32:11 -060027#define ACPI_END_TAG 0x79
28
Simon Glass03967ce2020-07-07 13:11:51 -060029/* ACPI Op/Prefix codes */
30enum {
Simon Glass83b2bd52020-07-07 13:11:52 -060031 ZERO_OP = 0x00,
32 ONE_OP = 0x01,
Simon Glass7aed90d2020-07-07 13:11:54 -060033 NAME_OP = 0x08,
Simon Glass83b2bd52020-07-07 13:11:52 -060034 BYTE_PREFIX = 0x0a,
35 WORD_PREFIX = 0x0b,
36 DWORD_PREFIX = 0x0c,
Simon Glass3df33bd2020-07-07 13:11:53 -060037 STRING_PREFIX = 0x0d,
Simon Glass83b2bd52020-07-07 13:11:52 -060038 QWORD_PREFIX = 0x0e,
Simon Glass82659cc2020-07-07 21:32:10 -060039 SCOPE_OP = 0x10,
Simon Glass29df8452020-07-07 13:11:55 -060040 BUFFER_OP = 0x11,
Simon Glass03967ce2020-07-07 13:11:51 -060041 PACKAGE_OP = 0x12,
Simon Glass9c70e7e2020-07-07 13:11:59 -060042 METHOD_OP = 0x14,
43 SLEEP_OP = 0x22,
Simon Glass7aed90d2020-07-07 13:11:54 -060044 DUAL_NAME_PREFIX = 0x2e,
45 MULTI_NAME_PREFIX = 0x2f,
Simon Glass9c70e7e2020-07-07 13:11:59 -060046 DEBUG_OP = 0x31,
47 EXT_OP_PREFIX = 0x5b,
Simon Glass0e5a0a02020-07-07 13:11:56 -060048 ROOT_PREFIX = 0x5c,
Simon Glass9c70e7e2020-07-07 13:11:59 -060049 LOCAL0_OP = 0x60,
50 LOCAL1_OP = 0x61,
51 LOCAL2_OP = 0x62,
52 LOCAL3_OP = 0x63,
53 LOCAL4_OP = 0x64,
54 LOCAL5_OP = 0x65,
55 LOCAL6_OP = 0x66,
56 LOCAL7_OP = 0x67,
Simon Glassda7cff32020-09-22 12:44:57 -060057 ARG0_OP = 0x68,
58 ARG1_OP = 0x69,
59 ARG2_OP = 0x6a,
60 ARG3_OP = 0x6b,
61 ARG4_OP = 0x6c,
62 ARG5_OP = 0x6d,
63 ARG6_OP = 0x6e,
Simon Glass9c70e7e2020-07-07 13:11:59 -060064 STORE_OP = 0x70,
65 AND_OP = 0x7b,
66 OR_OP = 0x7d,
67 NOT_OP = 0x80,
Simon Glass91c2f9c2020-07-07 21:32:14 -060068 DEVICE_OP = 0x82,
Simon Glass15403282020-09-22 12:45:11 -060069 PROCESSOR_OP = 0x83,
Simon Glassf9189d52020-07-07 13:12:00 -060070 POWER_RES_OP = 0x84,
Simon Glass15403282020-09-22 12:45:11 -060071 NOTIFY_OP = 0x86,
Simon Glassda7cff32020-09-22 12:44:57 -060072 LEQUAL_OP = 0x93,
73 TO_BUFFER_OP = 0x96,
74 TO_INTEGER_OP = 0x99,
75 IF_OP = 0xa0,
76 ELSE_OP = 0xa1,
Simon Glass9c70e7e2020-07-07 13:11:59 -060077 RETURN_OP = 0xa4,
Simon Glass03967ce2020-07-07 13:11:51 -060078};
79
Simon Glass61cc9332020-07-07 13:11:42 -060080/**
Simon Glass6c0da2d2020-09-22 12:45:08 -060081 * enum psd_coord - Coordination types for P-states
82 *
83 * The type of coordination that exists (hardware) or is required (software) as
84 * a result of the underlying hardware dependency
85 */
86enum psd_coord {
87 SW_ALL = 0xfc,
88 SW_ANY = 0xfd,
89 HW_ALL = 0xfe
90};
91
92/**
Simon Glass350c7f52020-09-22 12:45:13 -060093 * enum csd_coord - Coordination types for C-states
94 *
95 * The type of coordination that exists (hardware) or is required (software) as
96 * a result of the underlying hardware dependency
97 */
98enum csd_coord {
99 CSD_HW_ALL = 0xfe,
100};
101
102/**
103 * struct acpi_cstate - Information about a C-State
104 *
105 * @ctype: C State type (1=C1, 2=C2, 3=C3)
106 * @latency: Worst-case latency to enter and exit the C State (in uS)
107 * @power: Average power consumption of the processor when in this C-State (mW)
108 * @resource: Register to read to place the processor in this state
109 */
110struct acpi_cstate {
111 uint ctype;
112 uint latency;
113 uint power;
114 struct acpi_gen_regaddr resource;
115};
116
117/**
118 * struct acpi_tstate - Information about a Throttling Supported State
119 *
120 * See ACPI v6.3 section 8.4.5.2: _TSS (Throttling Supported States)
121 *
122 * @percent: Percent of the core CPU operating frequency that will be
123 * available when this throttling state is invoked
124 * @power: Throttling state’s maximum power dissipation (mw)
125 * @latency: Worst-case latency (uS) that the CPU is unavailable during a
126 * transition from any throttling state to this throttling state
127 * @control: Value to be written to the Processor Control Register
128 * (THROTTLE_CTRL) to initiate a transition to this throttling state
129 * @status: Value in THROTTLE_STATUS when in this state
130 */
131struct acpi_tstate {
132 uint percent;
133 uint power;
134 uint latency;
135 uint control;
136 uint status;
137};
138
139/**
Simon Glass61cc9332020-07-07 13:11:42 -0600140 * acpigen_get_current() - Get the current ACPI code output pointer
141 *
142 * @ctx: ACPI context pointer
143 * @return output pointer
144 */
145u8 *acpigen_get_current(struct acpi_ctx *ctx);
146
147/**
148 * acpigen_emit_byte() - Emit a byte to the ACPI code
149 *
150 * @ctx: ACPI context pointer
151 * @data: Value to output
152 */
153void acpigen_emit_byte(struct acpi_ctx *ctx, uint data);
154
155/**
156 * acpigen_emit_word() - Emit a 16-bit word to the ACPI code
157 *
158 * @ctx: ACPI context pointer
159 * @data: Value to output
160 */
161void acpigen_emit_word(struct acpi_ctx *ctx, uint data);
162
163/**
164 * acpigen_emit_dword() - Emit a 32-bit 'double word' to the ACPI code
165 *
166 * @ctx: ACPI context pointer
167 * @data: Value to output
168 */
169void acpigen_emit_dword(struct acpi_ctx *ctx, uint data);
170
Simon Glass7fb8da42020-07-07 13:11:45 -0600171/**
172 * acpigen_emit_stream() - Emit a stream of bytes
173 *
174 * @ctx: ACPI context pointer
175 * @data: Data to output
176 * @size: Size of data in bytes
177 */
178void acpigen_emit_stream(struct acpi_ctx *ctx, const char *data, int size);
179
180/**
181 * acpigen_emit_string() - Emit a string
182 *
183 * Emit a string with a null terminator
184 *
185 * @ctx: ACPI context pointer
186 * @str: String to output, or NULL for an empty string
187 */
188void acpigen_emit_string(struct acpi_ctx *ctx, const char *str);
189
Simon Glass7e148f22020-07-07 13:11:50 -0600190/**
191 * acpigen_write_len_f() - Write a 'forward' length placeholder
192 *
193 * This adds space for a length value in the ACPI stream and pushes the current
194 * position (before the length) on the stack. After calling this you can write
195 * some data and then call acpigen_pop_len() to update the length value.
196 *
197 * Usage:
198 *
199 * acpigen_write_len_f() ------\
200 * acpigen_write...() |
201 * acpigen_write...() |
202 * acpigen_write_len_f() --\ |
203 * acpigen_write...() | |
204 * acpigen_write...() | |
205 * acpigen_pop_len() ------/ |
206 * acpigen_write...() |
207 * acpigen_pop_len() ----------/
208 *
209 * See ACPI 6.3 section 20.2.4 Package Length Encoding
210 *
211 * This implementation always uses a 3-byte packet length for simplicity. It
212 * could be adjusted to support other lengths.
213 *
214 * @ctx: ACPI context pointer
215 */
216void acpigen_write_len_f(struct acpi_ctx *ctx);
217
218/**
219 * acpigen_pop_len() - Update the previously stacked length placeholder
220 *
221 * Call this after the data for the block has been written. It updates the
222 * top length value in the stack and pops it off.
223 *
224 * @ctx: ACPI context pointer
225 */
226void acpigen_pop_len(struct acpi_ctx *ctx);
227
Simon Glass03967ce2020-07-07 13:11:51 -0600228/**
229 * acpigen_write_package() - Start writing a package
230 *
231 * A package collects together a number of elements in the ACPI code. To write
232 * a package use:
233 *
234 * acpigen_write_package(ctx, 3);
235 * ...write things
236 * acpigen_pop_len()
237 *
238 * If you don't know the number of elements in advance, acpigen_write_package()
239 * returns a pointer to the value so you can update it later:
240 *
241 * char *num_elements = acpigen_write_package(ctx, 0);
242 * ...write things
243 * *num_elements += 1;
244 * ...write things
245 * *num_elements += 1;
246 * acpigen_pop_len()
247 *
248 * @ctx: ACPI context pointer
249 * @nr_el: Number of elements (0 if not known)
250 * @returns pointer to the number of elements, which can be updated by the
251 * caller if needed
252 */
253char *acpigen_write_package(struct acpi_ctx *ctx, int nr_el);
254
Simon Glass83b2bd52020-07-07 13:11:52 -0600255/**
Simon Glassfea96512020-07-07 21:32:09 -0600256 * acpigen_write_byte() - Write a byte
257 *
258 * @ctx: ACPI context pointer
259 * @data: Value to write
260 */
261void acpigen_write_byte(struct acpi_ctx *ctx, unsigned int data);
262
263/**
264 * acpigen_write_word() - Write a word
265 *
266 * @ctx: ACPI context pointer
267 * @data: Value to write
268 */
269void acpigen_write_word(struct acpi_ctx *ctx, unsigned int data);
270
271/**
272 * acpigen_write_dword() - Write a dword
273 *
274 * @ctx: ACPI context pointer
275 * @data: Value to write
276 */
277void acpigen_write_dword(struct acpi_ctx *ctx, unsigned int data);
278
279/**
280 * acpigen_write_qword() - Write a qword
281 *
282 * @ctx: ACPI context pointer
283 * @data: Value to write
284 */
285void acpigen_write_qword(struct acpi_ctx *ctx, u64 data);
286
287/**
288 * acpigen_write_zero() - Write zero
289 *
290 * @ctx: ACPI context pointer
291 */
292void acpigen_write_zero(struct acpi_ctx *ctx);
293
294/**
295 * acpigen_write_one() - Write one
296 *
297 * @ctx: ACPI context pointer
298 */
299void acpigen_write_one(struct acpi_ctx *ctx);
300
301/**
Simon Glass83b2bd52020-07-07 13:11:52 -0600302 * acpigen_write_integer() - Write an integer
303 *
304 * This writes an operation (BYTE_OP, WORD_OP, DWORD_OP, QWORD_OP depending on
305 * the integer size) and an integer value. Note that WORD means 16 bits in ACPI.
306 *
307 * @ctx: ACPI context pointer
308 * @data: Integer to write
309 */
310void acpigen_write_integer(struct acpi_ctx *ctx, u64 data);
311
Simon Glass3df33bd2020-07-07 13:11:53 -0600312/**
Simon Glassbb6772c2020-07-07 21:32:15 -0600313 * acpigen_write_name_zero() - Write a named zero value
314 *
315 * @ctx: ACPI context pointer
316 * @name: Name of the value
317 */
318void acpigen_write_name_zero(struct acpi_ctx *ctx, const char *name);
319
320/**
321 * acpigen_write_name_one() - Write a named one value
322 *
323 * @ctx: ACPI context pointer
324 * @name: Name of the value
325 */
326void acpigen_write_name_one(struct acpi_ctx *ctx, const char *name);
327
328/**
329 * acpigen_write_name_byte() - Write a named byte value
330 *
331 * @ctx: ACPI context pointer
332 * @name: Name of the value
333 * @val: Value to write
334 */
335void acpigen_write_name_byte(struct acpi_ctx *ctx, const char *name, uint val);
336
337/**
338 * acpigen_write_name_word() - Write a named word value
339 *
340 * @ctx: ACPI context pointer
341 * @name: Name of the value
342 * @val: Value to write
343 */
344void acpigen_write_name_word(struct acpi_ctx *ctx, const char *name, uint val);
345
346/**
347 * acpigen_write_name_dword() - Write a named dword value
348 *
349 * @ctx: ACPI context pointer
350 * @name: Name of the value
351 * @val: Value to write
352 */
353void acpigen_write_name_dword(struct acpi_ctx *ctx, const char *name, uint val);
354
355/**
356 * acpigen_write_name_qword() - Write a named qword value
357 *
358 * @ctx: ACPI context pointer
359 * @name: Name of the value
360 * @val: Value to write
361 */
362void acpigen_write_name_qword(struct acpi_ctx *ctx, const char *name, u64 val);
363
364/**
365 * acpigen_write_name_integer() - Write a named integer value
366 *
367 * @ctx: ACPI context pointer
368 * @name: Name of the value
369 * @val: Value to write
370 */
371void acpigen_write_name_integer(struct acpi_ctx *ctx, const char *name,
372 u64 val);
373
374/**
375 * acpigen_write_name_string() - Write a named string value
376 *
377 * @ctx: ACPI context pointer
378 * @name: Name of the value
379 * @string: String to write
380 */
381void acpigen_write_name_string(struct acpi_ctx *ctx, const char *name,
382 const char *string);
383
384/**
Simon Glass3df33bd2020-07-07 13:11:53 -0600385 * acpigen_write_string() - Write a string
386 *
387 * This writes a STRING_PREFIX followed by a null-terminated string
388 *
389 * @ctx: ACPI context pointer
390 * @str: String to write
391 */
392void acpigen_write_string(struct acpi_ctx *ctx, const char *str);
Simon Glass7aed90d2020-07-07 13:11:54 -0600393
394/**
395 * acpigen_emit_namestring() - Emit an ACPI name
396 *
397 * This writes out an ACPI name or path in the required special format. It does
398 * not add the NAME_OP prefix.
399 *
400 * @ctx: ACPI context pointer
401 * @namepath: Name / path to emit
402 */
403void acpigen_emit_namestring(struct acpi_ctx *ctx, const char *namepath);
404
405/**
406 * acpigen_write_name() - Write out an ACPI name
407 *
408 * This writes out an ACPI name or path in the required special format with a
409 * NAME_OP prefix.
410 *
411 * @ctx: ACPI context pointer
412 * @namepath: Name / path to emit
413 */
414void acpigen_write_name(struct acpi_ctx *ctx, const char *namepath);
Simon Glass29df8452020-07-07 13:11:55 -0600415
416/**
Simon Glass82659cc2020-07-07 21:32:10 -0600417 * acpigen_write_scope() - Write a scope
418 *
419 * @ctx: ACPI context pointer
420 * @scope: Scope to write (e.g. "\\_SB.ABCD")
421 */
422void acpigen_write_scope(struct acpi_ctx *ctx, const char *scope);
423
424/**
Simon Glass29df8452020-07-07 13:11:55 -0600425 * acpigen_write_uuid() - Write a UUID
426 *
427 * This writes out a UUID in the format used by ACPI, with a BUFFER_OP prefix.
428 *
429 * @ctx: ACPI context pointer
430 * @uuid: UUID to write in the form aabbccdd-eeff-gghh-iijj-kkllmmnnoopp
431 * @return 0 if OK, -EINVAL if the format is incorrect
432 */
433int acpigen_write_uuid(struct acpi_ctx *ctx, const char *uuid);
434
Simon Glass9c70e7e2020-07-07 13:11:59 -0600435/**
436 * acpigen_emit_ext_op() - Emit an extended op with the EXT_OP_PREFIX prefix
437 *
438 * @ctx: ACPI context pointer
439 * @op: Operation code (e.g. SLEEP_OP)
440 */
441void acpigen_emit_ext_op(struct acpi_ctx *ctx, uint op);
442
443/**
444 * acpigen_write_method() - Write a method header
445 *
446 * @ctx: ACPI context pointer
447 * @name: Method name (4 characters)
448 * @nargs: Number of method arguments (0 if none)
449 */
450void acpigen_write_method(struct acpi_ctx *ctx, const char *name, int nargs);
451
452/**
453 * acpigen_write_method_serialized() - Write a method header
454 *
455 * This sets the 'serialized' flag so that the method is thread-safe
456 *
457 * @ctx: ACPI context pointer
458 * @name: Method name (4 characters)
459 * @nargs: Number of method arguments (0 if none)
460 */
461void acpigen_write_method_serialized(struct acpi_ctx *ctx, const char *name,
462 int nargs);
463
464/**
Simon Glass91c2f9c2020-07-07 21:32:14 -0600465 * acpigen_write_device() - Write an ACPI device
466 *
467 * @ctx: ACPI context pointer
468 * @name: Device name to write
469 */
470void acpigen_write_device(struct acpi_ctx *ctx, const char *name);
471
472/**
Simon Glass9c70e7e2020-07-07 13:11:59 -0600473 * acpigen_write_sta() - Write a _STA method
474 *
475 * @ctx: ACPI context pointer
476 * @status: Status value to return
477 */
478void acpigen_write_sta(struct acpi_ctx *ctx, uint status);
479
480/**
Simon Glassd7d631d2020-07-07 21:32:11 -0600481 * acpigen_write_resourcetemplate_header() - Write a ResourceTemplate header
482 *
483 * @ctx: ACPI context pointer
484 */
485void acpigen_write_resourcetemplate_header(struct acpi_ctx *ctx);
486
487/**
488 * acpigen_write_resourcetemplate_footer() - Write a ResourceTemplate footer
489 *
490 * @ctx: ACPI context pointer
491 */
492void acpigen_write_resourcetemplate_footer(struct acpi_ctx *ctx);
493
494/**
495 * acpigen_write_register_resource() - Write a register resource
496 *
497 * This writes a header, the address information and a footer
498 *
499 * @ctx: ACPI context pointer
500 * @addr: Address to write
501 */
502void acpigen_write_register_resource(struct acpi_ctx *ctx,
503 const struct acpi_gen_regaddr *addr);
504
505/**
Simon Glass9c70e7e2020-07-07 13:11:59 -0600506 * acpigen_write_sleep() - Write a sleep operation
507 *
508 * @ctx: ACPI context pointer
509 * @sleep_ms: Number of milliseconds to sleep for
510 */
511void acpigen_write_sleep(struct acpi_ctx *ctx, u64 sleep_ms);
512
513/**
514 * acpigen_write_store() - Write a store operation
515 *
516 * @ctx: ACPI context pointer
517 */
518void acpigen_write_store(struct acpi_ctx *ctx);
519
520/**
521 * acpigen_write_debug_string() - Write a debug string
522 *
523 * This writes a debug operation with an associated string
524 *
525 * @ctx: ACPI context pointer
526 * @str: String to write
527 */
528void acpigen_write_debug_string(struct acpi_ctx *ctx, const char *str);
529
530/**
531 * acpigen_write_or() - Write a bitwise OR operation
532 *
533 * res = arg1 | arg2
534 *
535 * @ctx: ACPI context pointer
536 * @arg1: ACPI opcode for operand 1 (e.g. LOCAL0_OP)
537 * @arg2: ACPI opcode for operand 2 (e.g. LOCAL1_OP)
538 * @res: ACPI opcode for result (e.g. LOCAL2_OP)
539 */
540void acpigen_write_or(struct acpi_ctx *ctx, u8 arg1, u8 arg2, u8 res);
541
542/**
543 * acpigen_write_and() - Write a bitwise AND operation
544 *
545 * res = arg1 & arg2
546 *
547 * @ctx: ACPI context pointer
548 * @arg1: ACPI opcode for operand 1 (e.g. LOCAL0_OP)
549 * @arg2: ACPI opcode for operand 2 (e.g. LOCAL1_OP)
550 * @res: ACPI opcode for result (e.g. LOCAL2_OP)
551 */
552void acpigen_write_and(struct acpi_ctx *ctx, u8 arg1, u8 arg2, u8 res);
553
554/**
555 * acpigen_write_not() - Write a bitwise NOT operation
556 *
557 * res = ~arg1
558 *
559 * @ctx: ACPI context pointer
560 * @arg: ACPI opcode for operand (e.g. LOCAL0_OP)
561 * @res: ACPI opcode for result (e.g. LOCAL2_OP)
562 */
563void acpigen_write_not(struct acpi_ctx *ctx, u8 arg, u8 res);
564
Simon Glassf9189d52020-07-07 13:12:00 -0600565/**
566 * acpigen_write_power_res() - Write a power resource
567 *
568 * Name (_PRx, Package(One) { name })
569 * ...
570 * PowerResource (name, level, order)
571 *
572 * The caller should fill in the rest of the power resource and then call
573 * acpigen_pop_len() to close it off
574 *
575 * @ctx: ACPI context pointer
576 * @name: Name of power resource (e.g. "PRIC")
577 * @level: Deepest sleep level that this resource must be kept on (0=S0, 3=S3)
578 * @order: Order that this must be enabled/disabled (e.g. 0)
579 * @dev_stats: List of states to define, e.g. {"_PR0", "_PR3"}
580 * @dev_states_count: Number of dev states
581 */
582void acpigen_write_power_res(struct acpi_ctx *ctx, const char *name, uint level,
583 uint order, const char *const dev_states[],
584 size_t dev_states_count);
585
Simon Glassf8054dd2020-07-07 13:12:01 -0600586/**
587 * acpigen_set_enable_tx_gpio() - Emit ACPI code to enable/disable a GPIO
588 *
589 * This emits code to either enable to disable a Tx GPIO. It takes account of
590 * the GPIO polarity.
591 *
592 * The code needs access to the DW0 register for the pad being used. This is
593 * provided by gpio->pin0_addr and ACPI methods must be defined for the board
594 * which can read and write the pad's DW0 register given this address:
595 * @dw0_read: takes a single argument, the DW0 address
596 * returns the DW0 value
597 * @dw0:write: takes two arguments, the DW0 address and the value to write
598 * no return value
599 *
600 * Example code (-- means comment):
601 *
602 * -- Get Pad Configuration DW0 register value
603 * Method (GPC0, 0x1, Serialized)
604 * {
605 * -- Arg0 - GPIO DW0 address
606 * Store (Arg0, Local0)
607 * OperationRegion (PDW0, SystemMemory, Local0, 4)
608 * Field (PDW0, AnyAcc, NoLock, Preserve) {
609 * TEMP, 32
610 * }
611 * Return (TEMP)
612 * }
613 *
614 * -- Set Pad Configuration DW0 register value
615 * Method (SPC0, 0x2, Serialized)
616 * {
617 * -- Arg0 - GPIO DW0 address
618 * -- Arg1 - Value for DW0 register
619 * Store (Arg0, Local0)
620 * OperationRegion (PDW0, SystemMemory, Local0, 4)
621 * Field (PDW0, AnyAcc, NoLock, Preserve) {
622 * TEMP,32
623 * }
624 * Store (Arg1, TEMP)
625 * }
626 *
627 *
628 * @ctx: ACPI context pointer
629 * @tx_state_val: Mask to use to toggle the TX state on the GPIO pin, e,g.
630 * PAD_CFG0_TX_STATE
631 * @dw0_read: Method name to use to read dw0, e.g. "\\_SB.GPC0"
632 * @dw0_write: Method name to use to read dw0, e.g. "\\_SB.SPC0"
633 * @gpio: GPIO to change
634 * @enable: true to enable GPIO, false to disable
635 * Returns 0 on success, -ve on error.
636 */
637int acpigen_set_enable_tx_gpio(struct acpi_ctx *ctx, u32 tx_state_val,
638 const char *dw0_read, const char *dw0_write,
639 struct acpi_gpio *gpio, bool enable);
640
Simon Glasse0a896b2020-09-22 12:44:56 -0600641/**
642 * acpigen_write_prw() - Write a power resource for wake (_PRW)
643 *
644 * @ctx: ACPI context pointer
645 * @wake: GPE that wakes up the device
646 * @level: Deepest power system sleeping state that can be entered while still
647 * providing wake functionality
648 */
649void acpigen_write_prw(struct acpi_ctx *ctx, uint wake, uint level);
650
Simon Glassda7cff32020-09-22 12:44:57 -0600651/**
652 * acpigen_write_if() - Write an If block
653 *
654 * This requires a call to acpigen_pop_len() to complete the block
655 *
656 * @ctx: ACPI context pointer
657 */
658void acpigen_write_if(struct acpi_ctx *ctx);
659
660/**
661 * acpigen_write_if_lequal_op_int() - Write comparison between op and integer
662 *
663 * Generates ACPI code for checking if operand1 and operand2 are equal
664 *
665 * If (Lequal (op, val))
666 *
667 * @ctx: ACPI context pointer
668 * @op: Operand to check
669 * @val: Value to check against
670 */
671void acpigen_write_if_lequal_op_int(struct acpi_ctx *ctx, uint op, u64 val);
672
673/**
674 * acpigen_write_else() - Write an Ef block
675 *
676 * This requires a call to acpigen_pop_len() to complete the block
677 *
678 * @ctx: ACPI context pointer
679 */
680void acpigen_write_else(struct acpi_ctx *ctx);
681
682/**
683 * acpigen_write_to_buffer() - Write a ToBuffer operation
684 *
685 * E.g.: to generate: ToBuffer (Arg0, Local0)
686 * use acpigen_write_to_buffer(ctx, ARG0_OP, LOCAL0_OP)
687 *
688 * @ctx: ACPI context pointer
689 * @src: Source argument
690 * @dst: Destination argument
691 */
692void acpigen_write_to_buffer(struct acpi_ctx *ctx, uint src, uint dst);
693
694/**
695 * acpigen_write_to_integer() - Write a ToInteger operation
696 *
697 * E.g.: to generate: ToInteger (Arg0, Local0)
698 * use acpigen_write_to_integer(ctx, ARG0_OP, LOCAL0_OP)
699 *
700 * @ctx: ACPI context pointer
701 * @src: Source argument
702 * @dst: Destination argument
703 */
704void acpigen_write_to_integer(struct acpi_ctx *ctx, uint src, uint dst);
705
706/**
707 * acpigen_write_return_byte_buffer() - Write a return of a byte buffer
708 *
709 * @ctx: ACPI context pointer
710 * @arr: Array of bytes to return
711 * @size: Number of bytes
712 */
713void acpigen_write_return_byte_buffer(struct acpi_ctx *ctx, u8 *arr,
714 size_t size);
715
716/**
717 * acpigen_write_return_singleton_buffer() - Write a return of a 1-byte buffer
718 *
719 * @ctx: ACPI context pointer
720 * @arg: Byte to return
721 */
722void acpigen_write_return_singleton_buffer(struct acpi_ctx *ctx, uint arg);
723
724/**
725 * acpigen_write_return_byte() - Write a return of a byte
726 *
727 * @ctx: ACPI context pointer
728 * @arg: Byte to return
729 */
730void acpigen_write_return_byte(struct acpi_ctx *ctx, uint arg);
731
Simon Glass88490e12020-09-22 12:44:58 -0600732/**
733 * acpigen_write_dsm_start() - Start a _DSM method
734 *
735 * Generate ACPI AML code to start the _DSM method.
736 *
737 * The functions need to be called in the correct sequence as below.
738 *
739 * Within the <generate-code-here> region, Local0 and Local1 must be are left
740 * untouched, but Local2-Local7 can be used
741 *
742 * Arguments passed into _DSM method:
743 * Arg0 = UUID
744 * Arg1 = Revision
745 * Arg2 = Function index
746 * Arg3 = Function-specific arguments
747 *
748 * AML code generated looks like this:
749 * Method (_DSM, 4, Serialized) { -- acpigen_write_dsm_start)
750 * ToBuffer (Arg0, Local0)
751 * If (LEqual (Local0, ToUUID(uuid))) { -- acpigen_write_dsm_uuid_start
752 * ToInteger (Arg2, Local1)
753 * If (LEqual (Local1, 0)) { -- acpigen_write_dsm_uuid_start_cond
754 * <generate-code-here>
755 * } -- acpigen_write_dsm_uuid_end_cond
756 * ...
757 * If (LEqual (Local1, n)) { -- acpigen_write_dsm_uuid_start_cond
758 * <generate-code-here>
759 * } -- acpigen_write_dsm_uuid_end_cond
760 * Return (Buffer (One) { 0x0 })
761 * } -- acpigen_write_dsm_uuid_end
762 * ...
763 * If (LEqual (Local0, ToUUID(uuidn))) {
764 * ...
765 * }
766 * Return (Buffer (One) { 0x0 }) -- acpigen_write_dsm_end
767 * }
768 *
769 * @ctx: ACPI context pointer
770 */
771void acpigen_write_dsm_start(struct acpi_ctx *ctx);
772
773/**
774 * acpigen_write_dsm_uuid_start() - Start a new UUID block
775 *
776 * This starts generation of code to handle a particular UUID:
777 *
778 * If (LEqual (Local0, ToUUID(uuid))) {
779 * ToInteger (Arg2, Local1)
780 *
781 * @ctx: ACPI context pointer
782 */
783int acpigen_write_dsm_uuid_start(struct acpi_ctx *ctx, const char *uuid);
784
785/**
786 * acpigen_write_dsm_uuid_start_cond() - Start a new condition block
787 *
788 * This starts generation of condition-checking code to handle a particular
789 * function:
790 *
791 * If (LEqual (Local1, i))
792 *
793 * @ctx: ACPI context pointer
794 */
795void acpigen_write_dsm_uuid_start_cond(struct acpi_ctx *ctx, int seq);
796
797/**
798 * acpigen_write_dsm_uuid_end_cond() - Start a new condition block
799 *
800 * This ends generation of condition-checking code to handle a particular
801 * function:
802 *
803 * }
804 *
805 * @ctx: ACPI context pointer
806 */
807void acpigen_write_dsm_uuid_end_cond(struct acpi_ctx *ctx);
808
809/**
810 * acpigen_write_dsm_uuid_end() - End a UUID block
811 *
812 * This ends generation of code to handle a particular UUID:
813 *
814 * Return (Buffer (One) { 0x0 })
815 *
816 * @ctx: ACPI context pointer
817 */
818void acpigen_write_dsm_uuid_end(struct acpi_ctx *ctx);
819
820/**
821 * acpigen_write_dsm_end() - End a _DSM method
822 *
823 * This ends generates of the _DSM block:
824 *
825 * Return (Buffer (One) { 0x0 })
826 *
827 * @ctx: ACPI context pointer
828 */
829void acpigen_write_dsm_end(struct acpi_ctx *ctx);
830
Simon Glass15403282020-09-22 12:45:11 -0600831/**
832 * acpigen_write_processor() - Write a Processor package
833 *
834 * This emits a Processor package header with the required information. The
835 * caller must complete the information and call acpigen_pop_len() at the end
836 *
837 * @ctx: ACPI context pointer
838 * @cpuindex: CPU number
839 * @pblock_addr: PBlk system IO address
840 * @pblock_len: PBlk length
841 */
842void acpigen_write_processor(struct acpi_ctx *ctx, uint cpuindex,
843 u32 pblock_addr, uint pblock_len);
844
845/**
846 * acpigen_write_processor_package() - Write a package containing the processors
847 *
848 * The package containins the name of each processor in the SoC
849 *
850 * @ctx: ACPI context pointer
851 * @name: Package name (.e.g "PPKG")
852 * @first_core: Number of the first core (e.g. 0)
853 * @core_count: Number of cores (e.g. 4)
854 */
855void acpigen_write_processor_package(struct acpi_ctx *ctx, const char *name,
856 uint first_core, uint core_count);
857
858/**
859 * acpigen_write_processor_cnot() - Write a processor notification method
860 *
861 * This writes a method that notifies all CPU cores
862 *
863 * @ctx: ACPI context pointer
864 * @num_cores: Number of CPU cores
865 */
866void acpigen_write_processor_cnot(struct acpi_ctx *ctx, const uint num_cores);
867
Simon Glass350c7f52020-09-22 12:45:13 -0600868/**
869 * acpigen_write_ppc() - generates a function returning max P-states
870 *
871 * @ctx: ACPI context pointer
872 * @num_pstates: Number of pstates to return
873 */
874void acpigen_write_ppc(struct acpi_ctx *ctx, uint num_pstates);
875
876/**
877 * acpigen_write_ppc() - generates a function returning PPCM
878 *
879 * This returns the maximum number of supported P-states, as saved in the
880 * variable PPCM
881 *
882 * @ctx: ACPI context pointer
883 */
884void acpigen_write_ppc_nvs(struct acpi_ctx *ctx);
885
886/**
887 * acpigen_write_tpc() - Write a _TPC method that returns the TPC limit
888 *
889 * @ctx: ACPI context pointer
890 * @gnvs_tpc_limit: Variable that holds the TPC limit
891 */
892void acpigen_write_tpc(struct acpi_ctx *ctx, const char *gnvs_tpc_limit);
893
894/**
895 * acpigen_write_pss_package() - Write a PSS package
896 *
897 * See ACPI v6.3 section 8.4.6: Processor Performance Control
898 *
899 * @ctx: ACPI context pointer
900 * @corefreq: CPU core frequency in MHz
901 * @translat: worst-case latency in uS that the CPU is unavailable during a
902 * transition from any performance state to this performance state
903 * @busmlat: worst-case latency in microseconds that Bus Masters are prevented
904 * from accessing memory during a transition from any performance state to
905 * this performance state
906 * @control: Value to write to PERF_CTRL to move to this performance state
907 * @status: Expected PERF_STATUS value when in this state
908 */
909void acpigen_write_pss_package(struct acpi_ctx *ctx, uint corefreq, uint power,
910 uint translat, uint busmlat, uint control,
911 uint status);
912
913/**
914 * acpigen_write_psd_package() - Write a PSD package
915 *
916 * Writes a P-State dependency package
917 *
918 * See ACPI v6.3 section 8.4.6.5: _PSD (P-State Dependency)
919 *
920 * @ctx: ACPI context pointer
921 * @domain: Dependency domain number to which this P state entry belongs
922 * @numprocs: Number of processors belonging to the domain for this logical
923 * processor’s P-states
924 * @coordtype: Coordination type
925 */
926void acpigen_write_psd_package(struct acpi_ctx *ctx, uint domain, uint numprocs,
927 enum psd_coord coordtype);
928
929/**
930 * acpigen_write_cst_package() - Write a _CST package
931 *
932 * See ACPI v6.3 section 8.4.2.1: _CST (C States)
933 *
934 * @ctx: ACPI context pointer
935 * @entry: Array of entries
936 * @nentries; Number of entries
937 */
938void acpigen_write_cst_package(struct acpi_ctx *ctx,
939 const struct acpi_cstate *entry, int nentries);
940
941/**
942 * acpigen_write_csd_package() - Write a _CSD Package
943 *
944 * See ACPI v6.3 section 8.4.2.2: _CSD (C-State Dependency)
945 *
946 * @ctx: ACPI context pointer
947 * @domain: dependency domain number to which this C state entry belongs
948 * @numprocs: number of processors belonging to the domain for the particular
949 * C-state
950 * @coordtype: Co-ordination type
951 * @index: Index of the C-State entry in the _CST object for which the
952 * dependency applies
953 */
954void acpigen_write_csd_package(struct acpi_ctx *ctx, uint domain, uint numprocs,
955 enum csd_coord coordtype, uint index);
956
957/**
958 * acpigen_write_tss_package() - Write a _TSS package
959 *
960 * @ctx: ACPI context pointer
961 * @entry: Entries to write
962 * @nentries: Number of entries to write
963 */
964void acpigen_write_tss_package(struct acpi_ctx *ctx,
965 struct acpi_tstate *entry, int nentries);
966
967/**
968 * acpigen_write_tsd_package() - Write a _TSD package
969 *
970 * See ACPI v6.3 section 8.4.5.4: _TSD (T-State Dependency)
971 *
972 * @ctx: ACPI context pointer
973 * @domain: dependency domain number to which this T state entry belongs
974 * @numprocs: Number of processors belonging to the domain for this logical
975 * processor’s T-states
976 * @coordtype: Coordination type
977 */
978void acpigen_write_tsd_package(struct acpi_ctx *ctx, uint domain, uint numprocs,
979 enum psd_coord coordtype);
980
Simon Glass61cc9332020-07-07 13:11:42 -0600981#endif