/*
 *  yosys -- Yosys Open SYnthesis Suite
 *
 *  Copyright (C) 2012  Clifford Wolf <clifford@clifford.at>
 *  
 *  Permission to use, copy, modify, and/or distribute this software for any
 *  purpose with or without fee is hereby granted, provided that the above
 *  copyright notice and this permission notice appear in all copies.
 *  
 *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 *  ---
 *
 *  The internal logic cell simulation library.
 *
 *  This verilog library contains simple simulation models for the internal
 *  logic cells ($_NOT_ , $_AND_ , ...) that are generated by the default technology
 *  mapper (see "techmap.v" in this directory) and expected by the "abc" pass.
 *
 */

module  \$_BUF_ (A, Y);
input A;
output Y;
assign Y = A;
endmodule

module  \$_NOT_ (A, Y);
input A;
output Y;
assign Y = ~A;
endmodule

module  \$_AND_ (A, B, Y);
input A, B;
output Y;
assign Y = A & B;
endmodule

module  \$_NAND_ (A, B, Y);
input A, B;
output Y;
assign Y = ~(A & B);
endmodule

module  \$_OR_ (A, B, Y);
input A, B;
output Y;
assign Y = A | B;
endmodule

module  \$_NOR_ (A, B, Y);
input A, B;
output Y;
assign Y = ~(A | B);
endmodule

module  \$_XOR_ (A, B, Y);
input A, B;
output Y;
assign Y = A ^ B;
endmodule

module  \$_XNOR_ (A, B, Y);
input A, B;
output Y;
assign Y = ~(A ^ B);
endmodule

module \$_MUX_ (A, B, S, Y);
input A, B, S;
output Y;
assign Y = S ? B : A;
endmodule

module \$_MUX4_ (A, B, C, D, S, T, Y);
input A, B, C, D, S, T;
output Y;
assign Y = T ? (S ? D : C) :
               (S ? B : A);
endmodule

module \$_MUX8_ (A, B, C, D, E, F, G, H, S, T, U, Y);
input A, B, C, D, E, F, G, H, S, T, U;
output Y;
assign Y = U ? T ? (S ? H : G) :
                   (S ? F : E) :
               T ? (S ? D : C) :
                   (S ? B : A);
endmodule

module \$_MUX16_ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, S, T, U, V, Y);
input A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, S, T, U, V;
output Y;
assign Y = V ? U ? T ? (S ? P : O) :
                       (S ? N : M) :
                   T ? (S ? L : K) :
                       (S ? J : I) :
               U ? T ? (S ? H : G) :
                       (S ? F : E) :
                   T ? (S ? D : C) :
                       (S ? B : A);
endmodule

module  \$_AOI3_ (A, B, C, Y);
input A, B, C;
output Y;
assign Y = ~((A & B) | C);
endmodule

module  \$_OAI3_ (A, B, C, Y);
input A, B, C;
output Y;
assign Y = ~((A | B) & C);
endmodule

module  \$_AOI4_ (A, B, C, D, Y);
input A, B, C, D;
output Y;
assign Y = ~((A & B) | (C & D));
endmodule

module  \$_OAI4_ (A, B, C, D, Y);
input A, B, C, D;
output Y;
assign Y = ~((A | B) & (C | D));
endmodule

module  \$_SR_NN_ (S, R, Q);
input S, R;
output reg Q;
always @(negedge S, negedge R) begin
	if (R == 0)
		Q <= 0;
	else if (S == 0)
		Q <= 1;
end
endmodule

module  \$_SR_NP_ (S, R, Q);
input S, R;
output reg Q;
always @(negedge S, posedge R) begin
	if (R == 1)
		Q <= 0;
	else if (S == 0)
		Q <= 1;
end
endmodule

module  \$_SR_PN_ (S, R, Q);
input S, R;
output reg Q;
always @(posedge S, negedge R) begin
	if (R == 0)
		Q <= 0;
	else if (S == 1)
		Q <= 1;
end
endmodule

module  \$_SR_PP_ (S, R, Q);
input S, R;
output reg Q;
always @(posedge S, posedge R) begin
	if (R == 1)
		Q <= 0;
	else if (S == 1)
		Q <= 1;
end
endmodule

module  \$_DFF_N_ (D, Q, C);
input D, C;
output reg Q;
always @(negedge C) begin
	Q <= D;
end
endmodule

module  \$_DFF_P_ (D, Q, C);
input D, C;
output reg Q;
always @(posedge C) begin
	Q <= D;
end
endmodule

module  \$_DFFE_NN_ (D, Q, C, E);
input D, C, E;
output reg Q;
always @(negedge C) begin
	if (!E) Q <= D;
end
endmodule

module  \$_DFFE_NP_ (D, Q, C, E);
input D, C, E;
output reg Q;
always @(negedge C) begin
	if (E) Q <= D;
end
endmodule

module  \$_DFFE_PN_ (D, Q, C, E);
input D, C, E;
output reg Q;
always @(posedge C) begin
	if (!E) Q <= D;
end
endmodule

module  \$_DFFE_PP_ (D, Q, C, E);
input D, C, E;
output reg Q;
always @(posedge C) begin
	if (E) Q <= D;
end
endmodule

module  \$_DFF_NN0_ (D, Q, C, R);
input D, C, R;
output reg Q;
always @(negedge C or negedge R) begin
	if (R == 0)
		Q <= 0;
	else
		Q <= D;
end
endmodule

module  \$_DFF_NN1_ (D, Q, C, R);
input D, C, R;
output reg Q;
always @(negedge C or negedge R) begin
	if (R == 0)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFF_NP0_ (D, Q, C, R);
input D, C, R;
output reg Q;
always @(negedge C or posedge R) begin
	if (R == 1)
		Q <= 0;
	else
		Q <= D;
end
endmodule

module  \$_DFF_NP1_ (D, Q, C, R);
input D, C, R;
output reg Q;
always @(negedge C or posedge R) begin
	if (R == 1)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFF_PN0_ (D, Q, C, R);
input D, C, R;
output reg Q;
always @(posedge C or negedge R) begin
	if (R == 0)
		Q <= 0;
	else
		Q <= D;
end
endmodule

module  \$_DFF_PN1_ (D, Q, C, R);
input D, C, R;
output reg Q;
always @(posedge C or negedge R) begin
	if (R == 0)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFF_PP0_ (D, Q, C, R);
input D, C, R;
output reg Q;
always @(posedge C or posedge R) begin
	if (R == 1)
		Q <= 0;
	else
		Q <= D;
end
endmodule

module  \$_DFF_PP1_ (D, Q, C, R);
input D, C, R;
output reg Q;
always @(posedge C or posedge R) begin
	if (R == 1)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFFSR_NNN_ (C, S, R, D, Q);
input C, S, R, D;
output reg Q;
always @(negedge C, negedge S, negedge R) begin
	if (R == 0)
		Q <= 0;
	else if (S == 0)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFFSR_NNP_ (C, S, R, D, Q);
input C, S, R, D;
output reg Q;
always @(negedge C, negedge S, posedge R) begin
	if (R == 1)
		Q <= 0;
	else if (S == 0)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFFSR_NPN_ (C, S, R, D, Q);
input C, S, R, D;
output reg Q;
always @(negedge C, posedge S, negedge R) begin
	if (R == 0)
		Q <= 0;
	else if (S == 1)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFFSR_NPP_ (C, S, R, D, Q);
input C, S, R, D;
output reg Q;
always @(negedge C, posedge S, posedge R) begin
	if (R == 1)
		Q <= 0;
	else if (S == 1)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFFSR_PNN_ (C, S, R, D, Q);
input C, S, R, D;
output reg Q;
always @(posedge C, negedge S, negedge R) begin
	if (R == 0)
		Q <= 0;
	else if (S == 0)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFFSR_PNP_ (C, S, R, D, Q);
input C, S, R, D;
output reg Q;
always @(posedge C, negedge S, posedge R) begin
	if (R == 1)
		Q <= 0;
	else if (S == 0)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFFSR_PPN_ (C, S, R, D, Q);
input C, S, R, D;
output reg Q;
always @(posedge C, posedge S, negedge R) begin
	if (R == 0)
		Q <= 0;
	else if (S == 1)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DFFSR_PPP_ (C, S, R, D, Q);
input C, S, R, D;
output reg Q;
always @(posedge C, posedge S, posedge R) begin
	if (R == 1)
		Q <= 0;
	else if (S == 1)
		Q <= 1;
	else
		Q <= D;
end
endmodule

module  \$_DLATCH_N_ (E, D, Q);
input E, D;
output reg Q;
always @* begin
	if (E == 0)
		Q <= D;
end
endmodule

module  \$_DLATCH_P_ (E, D, Q);
input E, D;
output reg Q;
always @* begin
	if (E == 1)
		Q <= D;
end
endmodule

module  \$_DLATCHSR_NNN_ (E, S, R, D, Q);
input E, S, R, D;
output reg Q;
always @* begin
	if (R == 0)
		Q <= 0;
	else if (S == 0)
		Q <= 1;
	else if (E == 0)
		Q <= D;
end
endmodule

module  \$_DLATCHSR_NNP_ (E, S, R, D, Q);
input E, S, R, D;
output reg Q;
always @* begin
	if (R == 1)
		Q <= 0;
	else if (S == 0)
		Q <= 1;
	else if (E == 0)
		Q <= D;
end
endmodule

module  \$_DLATCHSR_NPN_ (E, S, R, D, Q);
input E, S, R, D;
output reg Q;
always @* begin
	if (R == 0)
		Q <= 0;
	else if (S == 1)
		Q <= 1;
	else if (E == 0)
		Q <= D;
end
endmodule

module  \$_DLATCHSR_NPP_ (E, S, R, D, Q);
input E, S, R, D;
output reg Q;
always @* begin
	if (R == 1)
		Q <= 0;
	else if (S == 1)
		Q <= 1;
	else if (E == 0)
		Q <= D;
end
endmodule

module  \$_DLATCHSR_PNN_ (E, S, R, D, Q);
input E, S, R, D;
output reg Q;
always @* begin
	if (R == 0)
		Q <= 0;
	else if (S == 0)
		Q <= 1;
	else if (E == 1)
		Q <= D;
end
endmodule

module  \$_DLATCHSR_PNP_ (E, S, R, D, Q);
input E, S, R, D;
output reg Q;
always @* begin
	if (R == 1)
		Q <= 0;
	else if (S == 0)
		Q <= 1;
	else if (E == 1)
		Q <= D;
end
endmodule

module  \$_DLATCHSR_PPN_ (E, S, R, D, Q);
input E, S, R, D;
output reg Q;
always @* begin
	if (R == 0)
		Q <= 0;
	else if (S == 1)
		Q <= 1;
	else if (E == 1)
		Q <= D;
end
endmodule

module  \$_DLATCHSR_PPP_ (E, S, R, D, Q);
input E, S, R, D;
output reg Q;
always @* begin
	if (R == 1)
		Q <= 0;
	else if (S == 1)
		Q <= 1;
	else if (E == 1)
		Q <= D;
end
endmodule

178' href='#n178'>178</a>
<a id='n179' href='#n179'>179</a>
<a id='n180' href='#n180'>180</a>
<a id='n181' href='#n181'>181</a>
<a id='n182' href='#n182'>182</a>
<a id='n183' href='#n183'>183</a>
<a id='n184' href='#n184'>184</a>
<a id='n185' href='#n185'>185</a>
<a id='n186' href='#n186'>186</a>
<a id='n187' href='#n187'>187</a>
<a id='n188' href='#n188'>188</a>
<a id='n189' href='#n189'>189</a>
<a id='n190' href='#n190'>190</a>
<a id='n191' href='#n191'>191</a>
<a id='n192' href='#n192'>192</a>
<a id='n193' href='#n193'>193</a>
<a id='n194' href='#n194'>194</a>
<a id='n195' href='#n195'>195</a>
<a id='n196' href='#n196'>196</a>
<a id='n197' href='#n197'>197</a>
<a id='n198' href='#n198'>198</a>
<a id='n199' href='#n199'>199</a>
<a id='n200' href='#n200'>200</a>
<a id='n201' href='#n201'>201</a>
<a id='n202' href='#n202'>202</a>
<a id='n203' href='#n203'>203</a>
<a id='n204' href='#n204'>204</a>
<a id='n205' href='#n205'>205</a>
<a id='n206' href='#n206'>206</a>
<a id='n207' href='#n207'>207</a>
<a id='n208' href='#n208'>208</a>
<a id='n209' href='#n209'>209</a>
<a id='n210' href='#n210'>210</a>
<a id='n211' href='#n211'>211</a>
<a id='n212' href='#n212'>212</a>
<a id='n213' href='#n213'>213</a>
<a id='n214' href='#n214'>214</a>
<a id='n215' href='#n215'>215</a>
<a id='n216' href='#n216'>216</a>
<a id='n217' href='#n217'>217</a>
<a id='n218' href='#n218'>218</a>
<a id='n219' href='#n219'>219</a>
<a id='n220' href='#n220'>220</a>
<a id='n221' href='#n221'>221</a>
<a id='n222' href='#n222'>222</a>
<a id='n223' href='#n223'>223</a>
<a id='n224' href='#n224'>224</a>
<a id='n225' href='#n225'>225</a>
<a id='n226' href='#n226'>226</a>
<a id='n227' href='#n227'>227</a>
<a id='n228' href='#n228'>228</a>
<a id='n229' href='#n229'>229</a>
<a id='n230' href='#n230'>230</a>
<a id='n231' href='#n231'>231</a>
<a id='n232' href='#n232'>232</a>
<a id='n233' href='#n233'>233</a>
<a id='n234' href='#n234'>234</a>
<a id='n235' href='#n235'>235</a>
<a id='n236' href='#n236'>236</a>
<a id='n237' href='#n237'>237</a>
<a id='n238' href='#n238'>238</a>
<a id='n239' href='#n239'>239</a>
<a id='n240' href='#n240'>240</a>
<a id='n241' href='#n241'>241</a>
<a id='n242' href='#n242'>242</a>
<a id='n243' href='#n243'>243</a>
<a id='n244' href='#n244'>244</a>
<a id='n245' href='#n245'>245</a>
<a id='n246' href='#n246'>246</a>
<a id='n247' href='#n247'>247</a>
<a id='n248' href='#n248'>248</a>
<a id='n249' href='#n249'>249</a>
<a id='n250' href='#n250'>250</a>
<a id='n251' href='#n251'>251</a>
</pre></td>
<td class='lines'><pre><code><style>pre { line-height: 125%; margin: 0; }
td.linenos pre { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
span.linenos { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
td.linenos pre.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight { background: #ffffff; }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="cm">/*</span>
<span class="cm">    ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,</span>
<span class="cm">                 2011,2012,2013 Giovanni Di Sirio.</span>

<span class="cm">    This file is part of ChibiOS/RT.</span>

<span class="cm">    ChibiOS/RT is free software; you can redistribute it and/or modify</span>
<span class="cm">    it under the terms of the GNU General Public License as published by</span>
<span class="cm">    the Free Software Foundation; either version 3 of the License, or</span>
<span class="cm">    (at your option) any later version.</span>

<span class="cm">    ChibiOS/RT is distributed in the hope that it will be useful,</span>
<span class="cm">    but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span class="cm">    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span class="cm">    GNU General Public License for more details.</span>

<span class="cm">    You should have received a copy of the GNU General Public License</span>
<span class="cm">    along with this program.  If not, see &lt;http://www.gnu.org/licenses/&gt;.</span>
<span class="cm">*/</span>

<span class="cm">/**</span>
<span class="cm"> * @file    chbsem.h</span>
<span class="cm"> * @brief   Binary semaphores structures and macros.</span>
<span class="cm"> *</span>
<span class="cm"> * @addtogroup binary_semaphores</span>
<span class="cm"> * @details Binary semaphores related APIs and services.</span>
<span class="cm"> *</span>
<span class="cm"> *          &lt;h2&gt;Operation mode&lt;/h2&gt;</span>
<span class="cm"> *          Binary semaphores are implemented as a set of macros that use the</span>
<span class="cm"> *          existing counting semaphores primitives. The difference between</span>
<span class="cm"> *          counting and binary semaphores is that the counter of binary</span>
<span class="cm"> *          semaphores is not allowed to grow above the value 1. Repeated</span>
<span class="cm"> *          signal operation are ignored. A binary semaphore can thus have</span>
<span class="cm"> *          only two defined states:</span>
<span class="cm"> *          - &lt;b&gt;Taken&lt;/b&gt;, when its counter has a value of zero or lower</span>
<span class="cm"> *            than zero. A negative number represent the number of threads</span>
<span class="cm"> *            queued on the binary semaphore.</span>
<span class="cm"> *          - &lt;b&gt;Not taken&lt;/b&gt;, when its counter has a value of one.</span>
<span class="cm"> *          .</span>
<span class="cm"> *          Binary semaphores are different from mutexes because there is no</span>
<span class="cm"> *          the concept of ownership, a binary semaphore can be taken by a</span>
<span class="cm"> *          thread and signaled by another thread or an interrupt handler,</span>
<span class="cm"> *          mutexes can only be taken and released by the same thread. Another</span>
<span class="cm"> *          difference is that binary semaphores, unlike mutexes, do not</span>
<span class="cm"> *          implement the priority inheritance protocol.&lt;br&gt;</span>
<span class="cm"> *          In order to use the binary semaphores APIs the @p CH_USE_SEMAPHORES</span>
<span class="cm"> *          option must be enabled in @p chconf.h.</span>
<span class="cm"> * @{</span>
<span class="cm"> */</span>

<span class="cp">#ifndef _CHBSEM_H_</span>
<span class="cp">#define _CHBSEM_H_</span>

<span class="cp">#if CH_USE_SEMAPHORES || defined(__DOXYGEN__)</span>

<span class="cm">/**</span>
<span class="cm"> * @extends Semaphore</span>
<span class="cm"> *</span>
<span class="cm"> * @brief   Binary semaphore type.</span>
<span class="cm"> */</span>
<span class="k">typedef</span> <span class="k">struct</span>  <span class="p">{</span>
  <span class="n">Semaphore</span>             <span class="n">bs_sem</span><span class="p">;</span>
<span class="p">}</span> <span class="n">BinarySemaphore</span><span class="p">;</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Data part of a static semaphore initializer.</span>
<span class="cm"> * @details This macro should be used when statically initializing a semaphore</span>
<span class="cm"> *          that is part of a bigger structure.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] name      the name of the semaphore variable</span>
<span class="cm"> * @param[in] taken     the semaphore initial state</span>
<span class="cm"> */</span>
<span class="cp">#define _BSEMAPHORE_DATA(name, taken)                                       \</span>
<span class="cp">  {_SEMAPHORE_DATA(name.bs_sem, ((taken) ? 0 : 1))}</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Static semaphore initializer.</span>
<span class="cm"> * @details Statically initialized semaphores require no explicit</span>
<span class="cm"> *          initialization using @p chBSemInit().</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] name      the name of the semaphore variable</span>
<span class="cm"> * @param[in] taken     the semaphore initial state</span>
<span class="cm"> */</span>
<span class="cp">#define BSEMAPHORE_DECL(name, taken)                                        \</span>
<span class="cp">  BinarySemaphore name = _BSEMAPHORE_DATA(name, taken)</span>

<span class="cm">/**</span>
<span class="cm"> * @name    Macro Functions</span>
<span class="cm"> * @{</span>
<span class="cm"> */</span>
<span class="cm">/**</span>
<span class="cm"> * @brief   Initializes a binary semaphore.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[out] bsp      pointer to a @p BinarySemaphore structure</span>
<span class="cm"> * @param[in] taken     initial state of the binary semaphore:</span>
<span class="cm"> *                      - @a FALSE, the initial state is not taken.</span>
<span class="cm"> *                      - @a TRUE, the initial state is taken.</span>
<span class="cm"> *                      .</span>
<span class="cm"> *</span>
<span class="cm"> * @init</span>
<span class="cm"> */</span>
<span class="cp">#define chBSemInit(bsp, taken) chSemInit(&amp;(bsp)-&gt;bs_sem, (taken) ? 0 : 1)</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Wait operation on the binary semaphore.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] bsp       pointer to a @p BinarySemaphore structure</span>
<span class="cm"> * @return              A message specifying how the invoking thread has been</span>
<span class="cm"> *                      released from the semaphore.</span>
<span class="cm"> * @retval RDY_OK       if the binary semaphore has been successfully taken.</span>
<span class="cm"> * @retval RDY_RESET    if the binary semaphore has been reset using</span>
<span class="cm"> *                      @p bsemReset().</span>
<span class="cm"> *</span>
<span class="cm"> * @api</span>
<span class="cm"> */</span>
<span class="cp">#define chBSemWait(bsp) chSemWait(&amp;(bsp)-&gt;bs_sem)</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Wait operation on the binary semaphore.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] bsp       pointer to a @p BinarySemaphore structure</span>
<span class="cm"> * @return              A message specifying how the invoking thread has been</span>
<span class="cm"> *                      released from the semaphore.</span>
<span class="cm"> * @retval RDY_OK       if the binary semaphore has been successfully taken.</span>
<span class="cm"> * @retval RDY_RESET    if the binary semaphore has been reset using</span>
<span class="cm"> *                      @p bsemReset().</span>
<span class="cm"> *</span>
<span class="cm"> * @sclass</span>
<span class="cm"> */</span>
<span class="cp">#define chBSemWaitS(bsp) chSemWaitS(&amp;(bsp)-&gt;bs_sem)</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Wait operation on the binary semaphore.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] bsp       pointer to a @p BinarySemaphore structure</span>
<span class="cm"> * @param[in] time      the number of ticks before the operation timeouts,</span>
<span class="cm"> *                      the following special values are allowed:</span>
<span class="cm"> *                      - @a TIME_IMMEDIATE immediate timeout.</span>
<span class="cm"> *                      - @a TIME_INFINITE no timeout.</span>
<span class="cm"> *                      .</span>
<span class="cm"> * @return              A message specifying how the invoking thread has been</span>
<span class="cm"> *                      released from the semaphore.</span>
<span class="cm"> * @retval RDY_OK       if the binary semaphore has been successfully taken.</span>
<span class="cm"> * @retval RDY_RESET    if the binary semaphore has been reset using</span>
<span class="cm"> *                      @p bsemReset().</span>
<span class="cm"> * @retval RDY_TIMEOUT  if the binary semaphore has not been signaled or reset</span>
<span class="cm"> *                      within the specified timeout.</span>
<span class="cm"> *</span>
<span class="cm"> * @api</span>
<span class="cm"> */</span>
<span class="cp">#define chBSemWaitTimeout(bsp, time) chSemWaitTimeout(&amp;(bsp)-&gt;bs_sem, (time))</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Wait operation on the binary semaphore.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] bsp       pointer to a @p BinarySemaphore structure</span>
<span class="cm"> * @param[in] time      the number of ticks before the operation timeouts,</span>
<span class="cm"> *                      the following special values are allowed:</span>
<span class="cm"> *                      - @a TIME_IMMEDIATE immediate timeout.</span>
<span class="cm"> *                      - @a TIME_INFINITE no timeout.</span>
<span class="cm"> *                      .</span>
<span class="cm"> * @return              A message specifying how the invoking thread has been</span>
<span class="cm"> *                      released from the semaphore.</span>
<span class="cm"> * @retval RDY_OK       if the binary semaphore has been successfully taken.</span>
<span class="cm"> * @retval RDY_RESET    if the binary semaphore has been reset using</span>
<span class="cm"> *                      @p bsemReset().</span>
<span class="cm"> * @retval RDY_TIMEOUT  if the binary semaphore has not been signaled or reset</span>
<span class="cm"> *                      within the specified timeout.</span>
<span class="cm"> *</span>
<span class="cm"> * @sclass</span>
<span class="cm"> */</span>
<span class="cp">#define chBSemWaitTimeoutS(bsp, time) chSemWaitTimeoutS(&amp;(bsp)-&gt;bs_sem, (time))</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Reset operation on the binary semaphore.</span>
<span class="cm"> * @note    The released threads can recognize they were waked up by a reset</span>
<span class="cm"> *          rather than a signal because the @p bsemWait() will return</span>
<span class="cm"> *          @p RDY_RESET instead of @p RDY_OK.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] bsp       pointer to a @p BinarySemaphore structure</span>
<span class="cm"> * @param[in] taken     new state of the binary semaphore</span>
<span class="cm"> *                      - @a FALSE, the new state is not taken.</span>
<span class="cm"> *                      - @a TRUE, the new state is taken.</span>
<span class="cm"> *                      .</span>
<span class="cm"> *</span>
<span class="cm"> * @api</span>
<span class="cm"> */</span>
<span class="cp">#define chBSemReset(bsp, taken) chSemReset(&amp;(bsp)-&gt;bs_sem, (taken) ? 0 : 1)</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Reset operation on the binary semaphore.</span>
<span class="cm"> * @note    The released threads can recognize they were waked up by a reset</span>
<span class="cm"> *          rather than a signal because the @p bsemWait() will return</span>
<span class="cm"> *          @p RDY_RESET instead of @p RDY_OK.</span>
<span class="cm"> * @note    This function does not reschedule.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] bsp       pointer to a @p BinarySemaphore structure</span>
<span class="cm"> * @param[in] taken     new state of the binary semaphore</span>
<span class="cm"> *                      - @a FALSE, the new state is not taken.</span>
<span class="cm"> *                      - @a TRUE, the new state is taken.</span>
<span class="cm"> *                      .</span>
<span class="cm"> *</span>
<span class="cm"> * @iclass</span>
<span class="cm"> */</span>
<span class="cp">#define chBSemResetI(bsp, taken) chSemResetI(&amp;(bsp)-&gt;bs_sem, (taken) ? 0 : 1)</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Performs a signal operation on a binary semaphore.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] bsp       pointer to a @p BinarySemaphore structure</span>
<span class="cm"> *</span>
<span class="cm"> * @api</span>
<span class="cm"> */</span>
<span class="cp">#define chBSemSignal(bsp) {                                                 \</span>
<span class="cp">  chSysLock();                                                              \</span>
<span class="cp">  chBSemSignalI((bsp));                                                     \</span>
<span class="cp">  chSchRescheduleS();                                                       \</span>
<span class="cp">  chSysUnlock();                                                            \</span>
<span class="cp">}</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Performs a signal operation on a binary semaphore.</span>
<span class="cm"> * @note    This function does not reschedule.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] bsp       pointer to a @p BinarySemaphore structure</span>
<span class="cm"> *</span>
<span class="cm"> * @iclass</span>
<span class="cm"> */</span>
<span class="cp">#define chBSemSignalI(bsp) {                                                \</span>
<span class="cp">  if ((bsp)-&gt;bs_sem.s_cnt &lt; 1)                                              \</span>
<span class="cp">    chSemSignalI(&amp;(bsp)-&gt;bs_sem);                                           \</span>
<span class="cp">}</span>

<span class="cm">/**</span>
<span class="cm"> * @brief   Returns the binary semaphore current state.</span>
<span class="cm"> *</span>
<span class="cm"> * @param[in] bsp       pointer to a @p BinarySemaphore structure</span>
<span class="cm"> * @return              The binary semaphore current state.</span>
<span class="cm"> * @retval FALSE        if the binary semaphore is not taken.</span>
<span class="cm"> * @retval TRUE         if the binary semaphore is taken.</span>
<span class="cm"> *</span>
<span class="cm"> * @iclass</span>
<span class="cm"> */</span>
<span class="cp">#define chBSemGetStateI(bsp) ((bsp)-&gt;bs_sem.s_cnt &gt; 0 ? FALSE : TRUE)</span>
<span class="cm">/** @} */</span>

<span class="cp">#endif </span><span class="cm">/* CH_USE_SEMAPHORES */</span><span class="cp"></span>

<span class="cp">#endif </span><span class="cm">/* _CHBSEM_H_ */</span><span class="cp"></span>

<span class="cm">/** @} */</span>
</pre></div>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit v1.2.3</a> (<a href='https://git-scm.com/'>git 2.25.1</a>) at 2025-10-28 14:47:11 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>