aboutsummaryrefslogtreecommitdiffstats
path: root/manual/manual.tex
blob: 75f087ecae41e0c2b9ed040e9a5ed4cd5b760d8c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
\documentclass[oneside,a4paper]{book}

\usepackage[T1]{fontenc}   % required for luximono!
\usepackage{lmodern}
\usepackage[scaled=0.8]{luximono}  % typewriter font with bold face

% To install the luximono font files:
% getnonfreefonts-sys --all        or
% getnonfreefonts-sys luximono
%
% when there are trouble you might need to:
% - Create /etc/texmf/updmap.d/99local-luximono.cfg
%   containing the single line: Map ul9.map
% - Run update-updmap followed by mktexlsr and updmap-sys
%
% This commands must be executed as root with a root environment
% (i.e. run "sudo su" and then execute the commands in the root
% shell, don't just prefix the commands with "sudo").

% formats the text according the set language
\usepackage[english]{babel}
\usepackage[table,usenames]{xcolor}
% generates indices with the "\index" command
\usepackage{makeidx}
% enables import of graphics. We use pdflatex here so do the pdf optimisation.
%\usepackage[dvips]{graphicx}
\usepackage[pdftex]{graphicx}
\usepackage{pdfpages}
% includes floating objects like tables and figures.
\usepackage{float}
% for generating subfigures with ohne indented captions
\usepackage[hang]{subfigure}
% redefines and smartens captions of figures and tables (indentation, smaller and boldface)
\usepackage[hang,small,bf,center]{caption}
% enables tabstops and the numeration of lines
\usepackage{moreverb}
% enables user defined header and footer lines (former "fancyheadings")
\usepackage{fancyhdr}
% Some smart mathematical stuff
\usepackage{amsmath}
% Package for rotating several objects
\usepackage{rotating}
\usepackage{natbib}
\usepackage{epsf}
\usepackage{dsfont}
\usepackage[algochapter, boxruled, vlined]{algorithm2e}
%Activating and setting of character protruding - if you like
%\usepackage[activate,DVIoutput]{pdfcprot}
% If you really need special chars...
\usepackage[latin1]{inputenc}
% Hyperlinks
\usepackage[colorlinks,hyperindex,plainpages=false,%
pdftitle={Yosys Manual},%
pdfauthor={Clifford Wolf},%
%pdfkeywords={keyword},%
pdfpagelabels,%
pagebackref,%
bookmarksopen=false%
]{hyperref}
% For the two different reference lists ...
\usepackage{multibib}
\usepackage{multirow}
\usepackage{booktabs}
\usepackage{pdfpages}

\usepackage{listings}
\usepackage{pifont}
\usepackage{skull}
% \usepackage{draftwatermark}

\usepackage{tikz}
\usetikzlibrary{calc}
\usetikzlibrary{arrows}
\usetikzlibrary{scopes}
\usetikzlibrary{through}
\usetikzlibrary{shapes.geometric}

\lstset{basicstyle=\ttfamily}

\def\B#1{{\tt\textbackslash{}#1}}
\def\C#1{\lstinline[language=C++]{#1}}
\def\V#1{\lstinline[language=Verilog]{#1}}

\newsavebox{\fixmebox}
\newenvironment{fixme}%
{\newcommand\colboxcolor{FFBBBB}%
\begin{lrbox}{\fixmebox}%
\begin{minipage}{\dimexpr\columnwidth-2\fboxsep\relax}}
{\end{minipage}\end{lrbox}\textbf{FIXME: }\\%
\colorbox[HTML]{\colboxcolor}{\usebox{\fixmebox}}}

\newcites{weblink}{Internet References}

\setcounter{secnumdepth}{3}
\makeindex

\setlength{\oddsidemargin}{4mm}
\setlength{\evensidemargin}{-6mm}
\setlength{\textwidth}{162mm}
\setlength{\textheight}{230mm}
\setlength{\topmargin}{-5mm}

\setlength{\parskip}{1.5ex plus 1ex minus 0.5ex}
\setlength{\parindent}{0pt}

\lstdefinelanguage{liberty}{
	morecomment=[s]{/*}{*/},
	morekeywords={library,cell,area,pin,direction,function,clocked_on,next_state,clock,ff},
	morestring=[b]",
}

\lstdefinelanguage{rtlil}{
	morecomment=[l]{\#},
	morekeywords={module,attribute,parameter,wire,memory,auto,width,offset,size,input,output,inout,cell,connect,switch,case,assign,sync,low,high,posedge,negedge,edge,always,update,process,end},
	morestring=[b]",
}



\begin{document}

\fancypagestyle{mypagestyle}{%
\fancyhf{}%
\fancyhead[C]{\leftmark}%
\fancyfoot[C]{\thepage}%
\renewcommand{\headrulewidth}{0pt}%
\renewcommand{\footrulewidth}{0pt}}
\pagestyle{mypagestyle}

\thispagestyle{empty}
\null\vfil

\begin{center}
\bf\Huge Yosys Manual

\bigskip
\large Clifford Wolf
\end{center}

\vfil\null
\eject

\chapter*{Abstract}
Most of today's digital design is done in HDL code (mostly Verilog or VHDL) and
with the help of HDL synthesis tools.

In special cases such as synthesis for coarse-grain cell libraries or when
testing new synthesis algorithms it might be necessary to write a custom HDL
synthesis tool or add new features to an existing one. In these cases the
availability of a Free and Open Source (FOSS) synthesis tool that can be used
as basis for custom tools would be helpful.

In the absence of such a tool, the Yosys Open SYnthesis Suite (Yosys) was
developed. This document covers the design and implementation of this tool.
At the moment the main focus of Yosys lies on the high-level aspects of
digital synthesis. The pre-existing FOSS logic-synthesis tool ABC is used
by Yosys to perform advanced gate-level optimizations.

An evaluation of Yosys based on real-world designs is included. It is shown
that Yosys can be used as-is to synthesize such designs. The results produced
by Yosys in this tests where successfully verified using formal verification
and are comparable in quality to the results produced by a commercial
synthesis tool.

\bigskip

This document was originally published as bachelor thesis at the Vienna
University of Technology \cite{BACC}.

\chapter*{Abbreviations}
\begin{tabular}{ll}
AIG         & And-Inverter-Graph \\
ASIC        & Application-Specific Integrated Circuit \\
AST         & Abstract Syntax Tree \\
BDD         & Binary Decision Diagram \\
BLIF        & Berkeley Logic Interchange Format \\
EDA         & Electronic Design Automation \\
EDIF        & Electronic Design Interchange Format \\
ER Diagram  & Entity-Relationship Diagram \\
FOSS        & Free and Open-Source Software \\
FPGA        & Field-Programmable Gate Array \\
FSM         & Finite-state machine \\
HDL         & Hardware Description Language \\
LPM         & Library of Parameterized Modules \\
RTLIL       & RTL Intermediate Language \\
RTL         & Register Transfer Level \\
SAT         & Satisfiability Problem \\
% SSA       & Static Single Assignment Form \\
VHDL        & VHSIC Hardware Description Language \\
VHSIC       & Very-High-Speed Integrated Circuit \\
YOSYS       & Yosys Open SYnthesis Suite \\
\end{tabular}

\tableofcontents

\include{CHAPTER_Intro}
\include{CHAPTER_Basics}
\include{CHAPTER_Approach}
\include{CHAPTER_Overview}
\include{CHAPTER_CellLib}
\include{CHAPTER_Prog}

\include{CHAPTER_Verilog}
\include{CHAPTER_Optimize}
\include{CHAPTER_Techmap}
% \include{CHAPTER_Eval}

\appendix

\include{CHAPTER_Auxlibs}
\include{CHAPTER_Auxprogs}

\chapter{Command Reference Manual}
\label{commandref}
\input{command-reference-manual}

\include{CHAPTER_Appnotes}
% \include{CHAPTER_StateOfTheArt}

\bibliography{literature}
\bibliographystyle{alphadin}

\bibliographyweblink{weblinks}
\bibliographystyleweblink{abbrv}

\end{document}
ware may be distributed under the terms of the * GNU General Public License ("GPL") version 2 as published by the Free * Software Foundation. * * NO WARRANTY * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGES. */ #include <asm/io.h> #include <xen/config.h> #include <xen/init.h> #include <xen/types.h> #include <xen/errno.h> #include <acpi/acpi.h> #define _COMPONENT ACPI_HARDWARE ACPI_MODULE_NAME("hwregs") /******************************************************************************* * * FUNCTION: acpi_hw_get_register_bit_mask * * PARAMETERS: register_id - Index of ACPI Register to access * * RETURN: The bitmask to be used when accessing the register * * DESCRIPTION: Map register_id into a register bitmask. * ******************************************************************************/ struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id) { ACPI_FUNCTION_ENTRY(); if (register_id > ACPI_BITREG_MAX) { ACPI_DEBUG_PRINT((AE_INFO, "Invalid BitRegister ID: %X", register_id)); return (NULL); } return (&acpi_gbl_bit_register_info[register_id]); } /******************************************************************************* * * FUNCTION: acpi_get_register * * PARAMETERS: register_id - ID of ACPI bit_register to access * return_value - Value that was read from the register * * RETURN: Status and the value read from specified Register. Value * returned is normalized to bit0 (is shifted all the way right) * * DESCRIPTION: ACPI bit_register read function. * ******************************************************************************/ acpi_status acpi_get_register_unlocked(u32 register_id, u32 * return_value) { u32 register_value = 0; struct acpi_bit_register_info *bit_reg_info; acpi_status status; ACPI_FUNCTION_TRACE(acpi_get_register); /* Get the info structure corresponding to the requested ACPI Register */ bit_reg_info = acpi_hw_get_bit_register_info(register_id); if (!bit_reg_info) { return_ACPI_STATUS(AE_BAD_PARAMETER); } /* Read from the register */ status = acpi_hw_register_read(bit_reg_info->parent_register, &register_value); if (ACPI_SUCCESS(status)) { /* Normalize the value that was read */ register_value = ((register_value & bit_reg_info->access_bit_mask) >> bit_reg_info->bit_position); *return_value = register_value; ACPI_DEBUG_PRINT((ACPI_DB_IO, "Read value %8.8X register %X\n", register_value, bit_reg_info->parent_register)); } return_ACPI_STATUS(status); } acpi_status acpi_get_register(u32 register_id, u32 * return_value) { acpi_status status; //acpi_cpu_flags flags; //flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock); status = acpi_get_register_unlocked(register_id, return_value); //acpi_os_release_lock(acpi_gbl_hardware_lock, flags); return status; } /******************************************************************************* * * FUNCTION: acpi_set_register * * PARAMETERS: register_id - ID of ACPI bit_register to access * Value - (only used on write) value to write to the * Register, NOT pre-normalized to the bit pos * * RETURN: Status * * DESCRIPTION: ACPI Bit Register write function. * ******************************************************************************/ acpi_status acpi_set_register(u32 register_id, u32 value) { u32 register_value = 0; struct acpi_bit_register_info *bit_reg_info; acpi_status status; //acpi_cpu_flags lock_flags; ACPI_FUNCTION_TRACE_U32(acpi_set_register, register_id); /* Get the info structure corresponding to the requested ACPI Register */ bit_reg_info = acpi_hw_get_bit_register_info(register_id); if (!bit_reg_info) { ACPI_DEBUG_PRINT((AE_INFO, "Bad ACPI HW RegisterId: %X", register_id)); return_ACPI_STATUS(AE_BAD_PARAMETER); } //lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock); /* Always do a register read first so we can insert the new bits */ status = acpi_hw_register_read(bit_reg_info->parent_register, &register_value); if (ACPI_FAILURE(status)) { goto unlock_and_exit; } /* * Decode the Register ID * Register ID = [Register block ID] | [bit ID] * * Check bit ID to fine locate Register offset. * Check Mask to determine Register offset, and then read-write. */ switch (bit_reg_info->parent_register) { case ACPI_REGISTER_PM1_STATUS: /* * Status Registers are different from the rest. Clear by * writing 1, and writing 0 has no effect. So, the only relevant * information is the single bit we're interested in, all others should * be written as 0 so they will be left unchanged. */ value = ACPI_REGISTER_PREPARE_BITS(value, bit_reg_info->bit_position, bit_reg_info-> access_bit_mask); if (value) { status = acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS, (u16) value); register_value = 0; } break; case ACPI_REGISTER_PM1_ENABLE: ACPI_REGISTER_INSERT_VALUE(register_value, bit_reg_info->bit_position, bit_reg_info->access_bit_mask, value); status = acpi_hw_register_write(ACPI_REGISTER_PM1_ENABLE, (u16) register_value); break; case ACPI_REGISTER_PM1_CONTROL: /* * Write the PM1 Control register. * Note that at this level, the fact that there are actually TWO * registers (A and B - and B may not exist) is abstracted. */ ACPI_DEBUG_PRINT((ACPI_DB_IO, "PM1 control: Read %X\n", register_value)); ACPI_REGISTER_INSERT_VALUE(register_value, bit_reg_info->bit_position, bit_reg_info->access_bit_mask, value); status = acpi_hw_register_write(ACPI_REGISTER_PM1_CONTROL, (u16) register_value); break; case ACPI_REGISTER_PM2_CONTROL: status = acpi_hw_register_read(ACPI_REGISTER_PM2_CONTROL, &register_value); if (ACPI_FAILURE(status)) { goto unlock_and_exit; } ACPI_DEBUG_PRINT((ACPI_DB_IO, "PM2 control: Read %X from %8.8X%8.8X\n", register_value, ACPI_FORMAT_UINT64(acpi_gbl_FADT. xpm2_control_block. address))); ACPI_REGISTER_INSERT_VALUE(register_value, bit_reg_info->bit_position, bit_reg_info->access_bit_mask, value); ACPI_DEBUG_PRINT((ACPI_DB_IO, "About to write %4.4X to %8.8X%8.8X\n", register_value, ACPI_FORMAT_UINT64(acpi_gbl_FADT. xpm2_control_block. address))); status = acpi_hw_register_write(ACPI_REGISTER_PM2_CONTROL, (u8) (register_value)); break; default: break; } unlock_and_exit: //acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags); /* Normalize the value that was read */ ACPI_DEBUG_EXEC(register_value = ((register_value & bit_reg_info->access_bit_mask) >> bit_reg_info->bit_position)); ACPI_DEBUG_PRINT((ACPI_DB_IO, "Set bits: %8.8X actual %8.8X register %X\n", value, register_value, bit_reg_info->parent_register)); return_ACPI_STATUS(status); } /****************************************************************************** * * FUNCTION: acpi_hw_register_read * * PARAMETERS: register_id - ACPI Register ID * return_value - Where the register value is returned * * RETURN: Status and the value read. * * DESCRIPTION: Read from the specified ACPI register * ******************************************************************************/ acpi_status acpi_hw_register_read(u32 register_id, u32 * return_value) { u32 value1 = 0; u32 value2 = 0; acpi_status status; ACPI_FUNCTION_TRACE(hw_register_read); switch (register_id) { case ACPI_REGISTER_PM1_STATUS: /* 16-bit access */ status = acpi_hw_low_level_read(16, &value1, &acpi_gbl_FADT.xpm1a_event_block); if (ACPI_FAILURE(status)) { goto exit; } /* PM1B is optional */ status = acpi_hw_low_level_read(16, &value2, &acpi_gbl_FADT.xpm1b_event_block); value1 |= value2; break; case ACPI_REGISTER_PM1_ENABLE: /* 16-bit access */ status = acpi_hw_low_level_read(16, &value1, &acpi_gbl_xpm1a_enable); if (ACPI_FAILURE(status)) { goto exit; } /* PM1B is optional */ status = acpi_hw_low_level_read(16, &value2, &acpi_gbl_xpm1b_enable); value1 |= value2; break; case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */ status = acpi_hw_low_level_read(16, &value1, &acpi_gbl_FADT.xpm1a_control_block); if (ACPI_FAILURE(status)) { goto exit; } status = acpi_hw_low_level_read(16, &value2, &acpi_gbl_FADT.xpm1b_control_block); value1 |= value2; break; case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */ status = acpi_hw_low_level_read(8, &value1, &acpi_gbl_FADT.xpm2_control_block); break; case ACPI_REGISTER_PM_TIMER: /* 32-bit access */ status = acpi_hw_low_level_read(32, &value1, &acpi_gbl_FADT.xpm_timer_block); break; case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */ status = acpi_os_read_port(acpi_gbl_FADT.smi_command, &value1, 8); break; default: ACPI_DEBUG_PRINT((AE_INFO, "Unknown Register ID: %X", register_id)); status = AE_BAD_PARAMETER; break; } exit: if (ACPI_SUCCESS(status)) { *return_value = value1; } return_ACPI_STATUS(status); } /****************************************************************************** * * FUNCTION: acpi_hw_register_write * * PARAMETERS: register_id - ACPI Register ID * Value - The value to write * * RETURN: Status * * DESCRIPTION: Write to the specified ACPI register * * NOTE: In accordance with the ACPI specification, this function automatically * preserves the value of the following bits, meaning that these bits cannot be * changed via this interface: * * PM1_CONTROL[0] = SCI_EN * PM1_CONTROL[9] * PM1_STATUS[11] * * ACPI References: * 1) Hardware Ignored Bits: When software writes to a register with ignored * bit fields, it preserves the ignored bit fields * 2) SCI_EN: OSPM always preserves this bit position * ******************************************************************************/ acpi_status acpi_hw_register_write(u32 register_id, u32 value) { acpi_status status; u32 read_value; ACPI_FUNCTION_TRACE(hw_register_write); switch (register_id) { case ACPI_REGISTER_PM1_STATUS: /* 16-bit access */ /* Perform a read first to preserve certain bits (per ACPI spec) */ status = acpi_hw_register_read(ACPI_REGISTER_PM1_STATUS, &read_value); if (ACPI_FAILURE(status)) { goto exit; } /* Insert the bits to be preserved */ ACPI_INSERT_BITS(value, ACPI_PM1_STATUS_PRESERVED_BITS, read_value); /* Now we can write the data */ status = acpi_hw_low_level_write(16, value, &acpi_gbl_FADT.xpm1a_event_block); if (ACPI_FAILURE(status)) { goto exit; } /* PM1B is optional */ status = acpi_hw_low_level_write(16, value, &acpi_gbl_FADT.xpm1b_event_block); break; case ACPI_REGISTER_PM1_ENABLE: /* 16-bit access */ status = acpi_hw_low_level_write(16, value, &acpi_gbl_xpm1a_enable); if (ACPI_FAILURE(status)) { goto exit; } /* PM1B is optional */ status = acpi_hw_low_level_write(16, value, &acpi_gbl_xpm1b_enable); break; case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */ /* * Perform a read first to preserve certain bits (per ACPI spec) */ status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL, &read_value); if (ACPI_FAILURE(status)) { goto exit; } /* Insert the bits to be preserved */ ACPI_INSERT_BITS(value, ACPI_PM1_CONTROL_PRESERVED_BITS, read_value); /* Now we can write the data */ status = acpi_hw_low_level_write(16, value, &acpi_gbl_FADT.xpm1a_control_block); if (ACPI_FAILURE(status)) { goto exit; } status = acpi_hw_low_level_write(16, value, &acpi_gbl_FADT.xpm1b_control_block); break; case ACPI_REGISTER_PM1A_CONTROL: /* 16-bit access */ status = acpi_hw_low_level_write(16, value, &acpi_gbl_FADT.xpm1a_control_block); break; case ACPI_REGISTER_PM1B_CONTROL: /* 16-bit access */ status = acpi_hw_low_level_write(16, value, &acpi_gbl_FADT.xpm1b_control_block); break; case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */ status = acpi_hw_low_level_write(8, value, &acpi_gbl_FADT.xpm2_control_block); break; case ACPI_REGISTER_PM_TIMER: /* 32-bit access */ status = acpi_hw_low_level_write(32, value, &acpi_gbl_FADT.xpm_timer_block); break; case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */ /* SMI_CMD is currently always in IO space */ status = acpi_os_write_port(acpi_gbl_FADT.smi_command, value, 8); break; default: status = AE_BAD_PARAMETER; break; } exit: return_ACPI_STATUS(status); } /****************************************************************************** * * FUNCTION: acpi_hw_low_level_read * * PARAMETERS: Width - 8, 16, or 32 * Value - Where the value is returned * Reg - GAS register structure * * RETURN: Status * * DESCRIPTION: Read from either memory or IO space. * ******************************************************************************/ acpi_status acpi_hw_low_level_read(u32 width, u32 * value, struct acpi_generic_address *reg) { u64 address; acpi_status status; ACPI_FUNCTION_NAME(hw_low_level_read); /* * Must have a valid pointer to a GAS structure, and * a non-zero address within. However, don't return an error * because the PM1A/B code must not fail if B isn't present. */ if (!reg) { return (AE_OK); } /* Get a local copy of the address. Handles possible alignment issues */ ACPI_MOVE_64_TO_64(&address, &reg->address); if (!address) { return (AE_OK); } *value = 0; /* * Two address spaces supported: Memory or IO. * PCI_Config is not supported here because the GAS struct is insufficient */ switch (reg->space_id) { case ACPI_ADR_SPACE_SYSTEM_MEMORY: status = acpi_os_read_memory((acpi_physical_address) address, value, width); break; case ACPI_ADR_SPACE_SYSTEM_IO: status = acpi_os_read_port((acpi_io_address) address, value, width); break; default: return (AE_BAD_PARAMETER); } ACPI_DEBUG_PRINT((ACPI_DB_IO, "Read: %8.8X width %2d from %8.8X%8.8X (%s)\n", *value, width, ACPI_FORMAT_UINT64(address), acpi_ut_get_region_name(reg->address_space_id))); return (status); } /****************************************************************************** * * FUNCTION: acpi_hw_low_level_write * * PARAMETERS: Width - 8, 16, or 32 * Value - To be written * Reg - GAS register structure * * RETURN: Status * * DESCRIPTION: Write to either memory or IO space. * ******************************************************************************/ acpi_status acpi_hw_low_level_write(u32 width, u32 value, struct acpi_generic_address * reg) { u64 address; acpi_status status; ACPI_FUNCTION_NAME(hw_low_level_write); /* * Must have a valid pointer to a GAS structure, and * a non-zero address within. However, don't return an error * because the PM1A/B code must not fail if B isn't present. */ if (!reg) { return (AE_OK); } /* Get a local copy of the address. Handles possible alignment issues */ ACPI_MOVE_64_TO_64(&address, &reg->address); if (!address) { return (AE_OK); } /* * Two address spaces supported: Memory or IO. * PCI_Config is not supported here because the GAS struct is insufficient */ switch (reg->space_id) { case ACPI_ADR_SPACE_SYSTEM_MEMORY: status = acpi_os_write_memory((acpi_physical_address) address, value, width); break; case ACPI_ADR_SPACE_SYSTEM_IO: status = acpi_os_write_port((acpi_io_address) address, value, width); break; default: return (AE_BAD_PARAMETER); } ACPI_DEBUG_PRINT((ACPI_DB_IO, "Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n", value, width, ACPI_FORMAT_UINT64(address), acpi_ut_get_region_name(reg->address_space_id))); return (status); }