/*
 *  yosys -- Yosys Open SYnthesis Suite
 *
 *  Copyright (C) 2012  Claire Xenia Wolf <claire@yosyshq.com>
 *
 *  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 technology mapper.
 *
 *  This Verilog library contains the mapping of internal cells (e.g. $not with
 *  variable bit width) to the internal logic cells (such as the single bit $_NOT_
 *  gate). Usually this logic network is then mapped to the actual technology
 *  using e.g. the "abc" pass.
 *
 *  Note that this library does not map $mem cells. They must be mapped to logic
 *  and $dff cells using the "memory_map" pass first. (Or map it to custom cells,
 *  which is of course highly recommended for larger memories.)
 *
 */

`define MIN(_a, _b) ((_a) < (_b) ? (_a) : (_b))
`define MAX(_a, _b) ((_a) > (_b) ? (_a) : (_b))


// --------------------------------------------------------
// Use simplemap for trivial cell types
// --------------------------------------------------------

(* techmap_simplemap *)
(* techmap_celltype = "$not $and $or $xor $xnor" *)
module _90_simplemap_bool_ops;
endmodule

(* techmap_simplemap *)
(* techmap_celltype = "$reduce_and $reduce_or $reduce_xor $reduce_xnor $reduce_bool" *)
module _90_simplemap_reduce_ops;
endmodule

(* techmap_simplemap *)
(* techmap_celltype = "$logic_not $logic_and $logic_or" *)
module _90_simplemap_logic_ops;
endmodule

(* techmap_simplemap *)
(* techmap_celltype = "$eq $eqx $ne $nex" *)
module _90_simplemap_compare_ops;
endmodule

(* techmap_simplemap *)
(* techmap_celltype = "$pos $slice $concat $mux $tribuf" *)
module _90_simplemap_various;
endmodule

(* techmap_simplemap *)
(* techmap_celltype = "$sr $ff $dff $dffe $adff $adffe $aldff $aldffe $sdff $sdffe $sdffce $dffsr $dffsre $dlatch $adlatch $dlatchsr" *)
module _90_simplemap_registers;
endmodule


// --------------------------------------------------------
// Shift operators
// --------------------------------------------------------

(* techmap_celltype = "$shr $shl $sshl $sshr" *)
module _90_shift_ops_shr_shl_sshl_sshr (A, B, Y);
	parameter A_SIGNED = 0;
	parameter B_SIGNED = 0;
	parameter A_WIDTH = 1;
	parameter B_WIDTH = 1;
	parameter Y_WIDTH = 1;

	parameter _TECHMAP_CELLTYPE_ = "";
	localparam shift_left = _TECHMAP_CELLTYPE_ == "$shl" || _TECHMAP_CELLTYPE_ == "$sshl";
	localparam sign_extend = A_SIGNED && _TECHMAP_CELLTYPE_ == "$sshr";

	(* force_downto *)
	input [A_WIDTH-1:0] A;
	(* force_downto *)
	input [B_WIDTH-1:0] B;
	(* force_downto *)
	output [Y_WIDTH-1:0] Y;

	localparam WIDTH = `MAX(A_WIDTH, Y_WIDTH);
	localparam BB_WIDTH = `MIN($clog2(shift_left ? Y_WIDTH : A_SIGNED ? WIDTH : A_WIDTH) + 1, B_WIDTH);

	wire [1023:0] _TECHMAP_DO_00_ = "proc;;";
	wire [1023:0] _TECHMAP_DO_01_ = "RECURSION; CONSTMAP; opt_muxtree; opt_expr -mux_undef -mux_bool -fine;;;";

	integer i;
	(* force_downto *)
	reg [WIDTH-1:0] buffer;
	reg overflow;

	always @* begin
		overflow = B_WIDTH > BB_WIDTH ? |B[B_WIDTH-1:BB_WIDTH] : 1'b0;
		buffer = overflow ? {WIDTH{sign_extend ? A[A_WIDTH-1] : 1'b0}} : {{WIDTH-A_WIDTH{A_SIGNED ? A[A_WIDTH-1] : 1'b0}}, A};

		for (i = 0; i < BB_WIDTH; i = i+1)
			if (B[i]) begin
				if (shift_left)
					buffer = {buffer, (2**i)'b0};
				else if (2**i < WIDTH)
					buffer = {{2**i{sign_extend ? buffer[WIDTH-1] : 1'b0}}, buffer[WIDTH-1 : 2**i]};
				else
					buffer = {WIDTH{sign_extend ? buffer[WIDTH-1] : 1'b0}};
			end
	end

	assign Y = buffer;
endmodule

(* techmap_celltype = "$shift $shiftx" *)
module _90_shift_shiftx (A, B, Y);
	parameter A_SIGNED = 0;
	parameter B_SIGNED = 0;
	parameter A_WIDTH = 1;
	parameter B_WIDTH = 1;
	parameter Y_WIDTH = 1;

	(* force_downto *)
	input [A_WIDTH-1:0] A;
	(* force_downto *)
	input [B_WIDTH-1:0] B;
	(* force_downto *)
	output [Y_WIDTH-1:0] Y;

	parameter _TECHMAP_CELLTYPE_ = "";
	parameter [B_WIDTH-1:0] _TECHMAP_CONSTMSK_B_ = 0;
	parameter [B_WIDTH-1:0] _TECHMAP_CONSTVAL_B_ = 0;

	localparam extbit = _TECHMAP_CELLTYPE_ == "$shift" ? 1'b0 : 1'bx;
	wire a_padding = _TECHMAP_CELLTYPE_ == "$shiftx" ? extbit : (A_SIGNED ? A[A_WIDTH-1] : 1'b0);

	localparam BB_WIDTH = `MIN($clog2(`MAX(A_WIDTH, Y_WIDTH)) + (B_SIGNED ? 2 : 1), B_WIDTH);
	localparam WIDTH = `MAX(A_WIDTH, Y_WIDTH) + (B_SIGNED ? 2**(BB_WIDTH-1) : 0);

	wire [1023:0] _TECHMAP_DO_00_ = "proc;;";
	wire [1023:0] _TECHMAP_DO_01_ = "CONSTMAP; opt_muxtree; opt_expr -mux_undef -mux_bool -fine;;;";

	integer i;
	(* force_downto *)
	reg [WIDTH-1:0] buffer;
	reg overflow;

	always @* begin
		overflow = 0;
		buffer = {WIDTH{extbit}};
		buffer[Y_WIDTH-1:0] = {Y_WIDTH{a_padding}};
		buffer[A_WIDTH-1:0] = A;

		if (B_WIDTH > BB_WIDTH) begin
			if (B_SIGNED) begin
				for (i = BB_WIDTH; i < B_WIDTH; i = i+1)
					if (B[i] != B[BB_WIDTH-1])
						overflow = 1;
			end else
				overflow = |B[B_WIDTH-1:BB_WIDTH];
			if (overflow)
				buffer = {WIDTH{extbit}};
		end

		if (B_SIGNED && B[BB_WIDTH-1])
			buffer = {buffer, {2**(BB_WIDTH-1){extbit}}};

		for (i = 0; i < (B_SIGNED ? BB_WIDTH-1 : BB_WIDTH); i = i+1)
			if (B[i]) begin
				if (2**i < WIDTH)
					buffer = {{2**i{extbit}}, buffer[WIDTH-1 : 2**i]};
				else
					buffer = {WIDTH{extbit}};
			end
	end
	assign Y = buffer;
endmodule


// --------------------------------------------------------
// Arithmetic operators
// --------------------------------------------------------

(* techmap_celltype = "$fa" *)
module _90_fa (A, B, C, X, Y);
	parameter WIDTH = 1;

	(* force_downto *)
	input [WIDTH-1:0] A, B, C;
	(* force_downto *)
	output [WIDTH-1:0] X, Y;

	(* force_downto *)
	wire [WIDTH-1:0] t1, t2, t3;

	assign t1 = A ^ B, t2 = A & B, t3 = C & t1;
	assign Y = t1 ^ C, X = t2 | t3;
endmodule

(* techmap_celltype = "$lcu" *)
module _90_lcu (P, G, CI, CO);
	parameter WIDTH = 2;

	(* force_downto *)
	input [WIDTH-1:0] P, G;
	input CI;

	(* force_downto *)
	output [WIDTH-1:0] CO;

	integer i, j;
	(* force_downto *)
	reg [WIDTH-1:0] p, g;

	wire [1023:0] _TECHMAP_DO_ = "proc; opt -fast";

	always @* begin
		p = P;
		g = G;

		// in almost all cases CI will be constant zero
		g[0] = g[0] | (p[0] & CI);

		// [[CITE]] Brent Kung Adder
		// R. P. Brent and H. T. Kung, "A Regular Layout for Parallel Adders",
		// IEEE Transaction on Computers, Vol. C-31, No. 3, p. 260-264, March, 1982

		// Main tree
		for (i = 1; i <= $clog2(WIDTH); i = i+1) begin
			for (j = 2**i - 1; j < WIDTH; j = j + 2**i) begin
				g[j] = g[j] | p[j] & g[j - 2**(i-1)];
				p[j] = p[j] & p[j - 2**(i-1)];
			end
		end

		// Inverse tree
		for (i = $clog2(WIDTH); i > 0; i = i-1) begin
			for (j = 2**i + 2**(i-1) - 1; j < WIDTH; j = j + 2**i) begin
				g[j] = g[j] | p[j] & g[j - 2**(i-1)];
				p[j] = p[j] & p[j - 2**(i-1)];
			end
		end
	end

	assign CO = g;
endmodule

(* techmap_celltype = "$alu" *)
module _90_alu (A, B, CI, BI, X, Y, CO);
	parameter A_SIGNED = 0;
	parameter B_SIGNED = 0;
	parameter A_WIDTH = 1;
	parameter B_WIDTH = 1;
	parameter Y_WIDTH = 1;

	(* force_downto *)
	input [A_WIDTH-1:0] A;
	(* force_downto *)
	input [B_WIDTH-1:0] B;
	(* force_downto *)
	output [Y_WIDTH-1:0] X, Y;

	input CI, BI;
	(* force_downto *)
	output [Y_WIDTH-1:0] CO;

	(* force_downto *)
	wire [Y_WIDTH-1:0] AA = A_buf;
	(* force_downto *)
	wire [Y_WIDTH-1:0] BB = BI ? ~B_buf : B_buf;

	(* force_downto *)
	wire [Y_WIDTH-1:0] A_buf, B_buf;
	\$pos #(.A_SIGNED(A_SIGNED), .A_WIDTH(A_WIDTH), .Y_WIDTH(Y_WIDTH)) A_conv (.A(A), .Y(A_buf));
	\$pos #(.A_SIGNED(B_SIGNED), .A_WIDTH(B_WIDTH), .Y_WIDTH(Y_WIDTH)) B_conv (.A(B), .Y(B_buf));

	\$lcu #(.WIDTH(Y_WIDTH)) lcu (.P(X), .G(AA & BB), .CI(CI), .CO(CO));

	assign X = AA ^ BB;
	assign Y = X ^ {CO, CI};
endmodule

(* techmap_maccmap *)
(* techmap_celltype = "$macc" *)
module _90_macc;
endmodule

(* techmap_wrap = "alumacc" *)
(* techmap_celltype = "$lt $le $ge $gt $add $sub $neg $mul" *)
module _90_alumacc;
endmodule


// --------------------------------------------------------
// Divide and Modulo
// --------------------------------------------------------

module \$__div_mod_u (A, B, Y, R);
	parameter WIDTH = 1;

	(* force_downto *)
	input [WIDTH-1:0] A, B;
	(* force_downto *)
	output [WIDTH-1:0] Y, R;

	(* force_downto *)
	wire [WIDTH*WIDTH-1:0] chaindata;
	assign R = chaindata[WIDTH*WIDTH-1:WIDTH*(WIDTH-1)];

	genvar i;
	generate begin
		for (i = 0; i < WIDTH; i=i+1) begin:stage
			(* force_downto *)
			wire [WIDTH-1:0] stage_in;

			if (i == 0) begin:cp
				assign stage_in = A;
			end else begin:cp
				assign stage_in = chaindata[i*WIDTH-1:(i-1)*WIDTH];
			end

			assign Y[WIDTH-(i+1)] = stage_in >= {B, {WIDTH-(i+1){1'b0}}};
			assign chaindata[(i+1)*WIDTH-1:i*WIDTH] = Y[WIDTH-(i+1)] ? stage_in - {B, {WIDTH-(i+1){1'b0}}} : stage_in;
		end
	end endgenerate
endmodule

// truncating signed division/modulo
module \$__div_mod_trunc (A, B, Y, R);
	parameter A_SIGNED = 0;
	parameter B_SIGNED = 0;
	parameter A_WIDTH = 1;
	parameter B_WIDTH = 1;
	parameter Y_WIDTH = 1;

	localparam WIDTH =
			A_WIDTH >= B_WIDTH && A_WIDTH >= Y_WIDTH ? A_WIDTH :
			B_WIDTH >= A_WIDTH && B_WIDTH >= Y_WIDTH ? B_WIDTH : Y_WIDTH;

	(* force_downto *)
	input [A_WIDTH-1:0] A;
	(* force_downto *)
	input [B_WIDTH-1:0] B;
	(* force_downto *)
	output [Y_WIDTH-1:0] Y, R;

	(* force_downto *)
	wire [WIDTH-1:0] A_buf, B_buf;
	\$pos #(.A_SIGNED(A_SIGNED), .A_WIDTH(A_WIDTH), .Y_WIDTH(WIDTH)) A_conv (.A(A), .Y(A_buf));
	\$pos #(.A_SIGNED(B_SIGNED), .A_WIDTH(B_WIDTH), .Y_WIDTH(WIDTH)) B_conv (.A(B), .Y(B_buf));

	(* force_downto *)
	wire [WIDTH-1:0] A_buf_u, B_buf_u, Y_u, R_u;
	assign A_buf_u = A_SIGNED && A_buf[WIDTH-1] ? -A_buf : A_buf;
	assign B_buf_u = B_SIGNED && B_buf[WIDTH-1] ? -B_buf : B_buf;

	\$__div_mod_u #(
		.WIDTH(WIDTH)
	) div_mod_u (
		.A(A_buf_u),
		.B(B_buf_u),
		.Y(Y_u),
		.R(R_u)
	);

	assign Y = A_SIGNED && B_SIGNED && (A_buf[WIDTH-1] != B_buf[WIDTH-1]) ? -Y_u : Y_u;
	assign R = A_SIGNED && B_SIGNED && A_buf[WIDTH-1] ? -R_u : R_u;
endmodule

(* techmap_celltype = "$div" *)
module _90_div (A, B, Y);
	parameter A_SIGNED = 0;
	parameter B_SIGNED = 0;
	parameter A_WIDTH = 1;
	parameter B_WIDTH = 1;
	parameter Y_WIDTH = 1;

	(* force_downto *)
	input [A_WIDTH-1:0] A;
	(* force_downto *)
	input [B_WIDTH-1:0] B;
	(* force_downto *)
	output [Y_WIDTH-1:0] Y;

	\$__div_mod_trunc #(
		.A_SIGNED(<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="c">#</span>
<span class="c"># Copyright (C) 2006-2013 OpenWrt.org</span>
<span class="c">#</span>
<span class="c"># This is free software, licensed under the GNU General Public License v2.</span>
<span class="c"># See /LICENSE for more information.</span>
<span class="c">#</span>

<span class="nv">INPUT_MODULES_MENU</span><span class="o">:=</span>Input modules

<span class="cp">define KernelPackage/hid</span>
  SUBMENU:<span class="o">=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>HID Devices
  DEPENDS:<span class="o">=</span>+kmod-input-core +kmod-input-evdev
  KCONFIG:<span class="o">=</span>CONFIG_HID <span class="nv">CONFIG_HIDRAW</span><span class="o">=</span>y <span class="nv">CONFIG_HID_BATTERY_STRENGTH</span><span class="o">=</span>y
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/hid/hid.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoLoad,61,hid<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/hid/description</span>
 Kernel modules <span class="k">for</span> HID devices
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">hid</span><span class="k">))</span>

<span class="cp">define KernelPackage/hid-generic</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>Generic HID device support
  DEPENDS:<span class="o">=</span>+kmod-hid
  KCONFIG:<span class="o">=</span>CONFIG_HID_GENERIC
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/hid/hid-generic.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,hid-generic<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/hid/description</span>
 Kernel modules <span class="k">for</span> generic HID device <span class="o">(</span>e.g. keyboards and mice<span class="o">)</span> support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">hid-generic</span><span class="k">))</span>

<span class="cp">define KernelPackage/input-core</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>Input device core
  KCONFIG:<span class="o">=</span>CONFIG_INPUT
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/input/input-core.ko
<span class="cp">endef</span>

<span class="cp">define KernelPackage/input-core/description</span>
 Kernel modules <span class="k">for</span> support of input device
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">input-core</span><span class="k">))</span>


<span class="cp">define KernelPackage/input-evdev</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>Input event device
  DEPENDS:<span class="o">=</span>+kmod-input-core
  KCONFIG:<span class="o">=</span>CONFIG_INPUT_EVDEV
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/input/evdev.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoLoad,60,evdev<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/input-evdev/description</span>
 Kernel modules <span class="k">for</span> support of input device events
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">input-evdev</span><span class="k">))</span>


<span class="cp">define KernelPackage/input-gpio-keys</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>GPIO key support
  DEPENDS:<span class="o">=</span> @GPIO_SUPPORT +kmod-input-core
  KCONFIG:<span class="o">=</span> <span class="se">\</span>
	CONFIG_KEYBOARD_GPIO <span class="se">\</span>
	<span class="nv">CONFIG_INPUT_KEYBOARD</span><span class="o">=</span>y
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/input/keyboard/gpio_keys.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,gpio_keys,1<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/input-gpio-keys/description</span>
 This driver implements support <span class="k">for</span> buttons connected
 to GPIO pins of various CPUs <span class="o">(</span>and some other chips<span class="o">)</span>.

 See also gpio-button-hotplug which is an alternative, lower overhead
 implementation that generates uevents instead of kernel input events.
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">input-gpio-keys</span><span class="k">))</span>


<span class="cp">define KernelPackage/input-gpio-keys-polled</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>Polled GPIO key support
  DEPENDS:<span class="o">=</span>@GPIO_SUPPORT +kmod-input-polldev
  KCONFIG:<span class="o">=</span> <span class="se">\</span>
	CONFIG_KEYBOARD_GPIO_POLLED <span class="se">\</span>
	<span class="nv">CONFIG_INPUT_KEYBOARD</span><span class="o">=</span>y
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/input/keyboard/gpio_keys_polled.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,gpio_keys_polled,1<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/input-gpio-keys-polled/description</span>
 Kernel module <span class="k">for</span> support polled GPIO keys input device

 See also gpio-button-hotplug which is an alternative, lower overhead
 implementation that generates uevents instead of kernel input events.
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">input-gpio-keys-polled</span><span class="k">))</span>


<span class="cp">define KernelPackage/input-gpio-encoder</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>GPIO rotary encoder
  DEPENDS:<span class="o">=</span>@GPIO_SUPPORT +kmod-input-core
  KCONFIG:<span class="o">=</span>CONFIG_INPUT_GPIO_ROTARY_ENCODER
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/input/misc/rotary_encoder.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,rotary_encoder<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/gpio-encoder/description</span>
 Kernel module to use rotary encoders connected to GPIO pins
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">input-gpio-encoder</span><span class="k">))</span>


<span class="cp">define KernelPackage/input-joydev</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>Joystick device support
  DEPENDS:<span class="o">=</span>+kmod-input-core
  KCONFIG:<span class="o">=</span>CONFIG_INPUT_JOYDEV
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/input/joydev.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,joydev<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/input-joydev/description</span>
 Kernel module <span class="k">for</span> joystick support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">input-joydev</span><span class="k">))</span>


<span class="cp">define KernelPackage/input-polldev</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>Polled Input device support
  DEPENDS:<span class="o">=</span>+kmod-input-core
  KCONFIG:<span class="o">=</span>CONFIG_INPUT_POLLDEV
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/input/input-polldev.ko
<span class="cp">endef</span>

<span class="cp">define KernelPackage/input-polldev/description</span>
 Kernel module <span class="k">for</span> support of polled input devices
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">input-polldev</span><span class="k">))</span>


<span class="cp">define KernelPackage/input-matrixkmap</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>Input matrix devices support
  DEPENDS:<span class="o">=</span>+kmod-input-core
  KCONFIG:<span class="o">=</span>CONFIG_INPUT_MATRIXKMAP
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/input/matrix-keymap.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,matrix-keymap<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/input-matrix/description</span>
 Kernel module support <span class="k">for</span> input matrix devices
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">input-matrixkmap</span><span class="k">))</span>


<span class="cp">define KernelPackage/keyboard-imx</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>IMX keypad support
  DEPENDS:<span class="o">=</span>@<span class="o">(</span>TARGET_mxs<span class="o">||</span>TARGET_imx6<span class="o">)</span> +kmod-input-matrixkmap
  KCONFIG:<span class="o">=</span> <span class="se">\</span>
	CONFIG_KEYBOARD_IMX <span class="se">\</span>
	<span class="nv">CONFIG_INPUT_KEYBOARD</span><span class="o">=</span>y
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/input/keyboard/imx_keypad.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,imx_keypad<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/keyboard-imx/description</span>
 Enable support <span class="k">for</span> IMX keypad port.
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">keyboard-imx</span><span class="k">))</span>


<span class="cp">define KernelPackage/input-uinput</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>INPUT_MODULES_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>user input module
  DEPENDS:<span class="o">=</span>+kmod-input-core
  KCONFIG:<span class="o">=</span> <span class="se">\</span>
	<span class="nv">CONFIG_INPUT_MISC</span><span class="o">=</span>y <span class="se">\</span>
	CONFIG_INPUT_UINPUT
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/drivers/input/misc/uinput.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,uinput<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/input-uinput/description</span>
  user input modules needed <span class="k">for</span> bluez
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">input-uinput</span><span class="k">))</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 2026-01-25 10:44:47 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>