-- VHDL PSL parser.
-- Copyright (C) 2009 Tristan Gingold
--
-- GHDL is free software; you can redistribute it and/or modify it under
-- the terms of the GNU General Public License as published by the Free
-- Software Foundation; either version 2, or (at your option) any later
-- version.
--
-- GHDL is distributed in the hope that it will be useful, but WITHOUT ANY
-- WARRANTY; without even the implied warranty of MERCHANTABILITY or
-- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-- for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with GHDL; see the file COPYING. If not, write to the Free
-- Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-- 02111-1307, USA.
with PSL.Nodes; use PSL.Nodes;
with Iirs;
with Scanner; use Scanner;
with PSL.Errors; use PSL.Errors;
with PSL.Priorities; use PSL.Priorities;
with Parse;
package body Parse_Psl is
function Create_Node_Loc (K : Nkind) return Node is
Res : Node;
begin
Res := PSL.Nodes.Create_Node (K);
Set_Location (Res, Get_Token_Location);
return Res;
end Create_Node_Loc;
function Parse_Number return Node is
Res : Node;
begin
if Current_Token = Tok_Integer then
Res := Create_Node_Loc (N_Number);
-- FIXME: handle overflow.
Set_Value (Res, Uns32 (Current_Iir_Int64));
Scan;
return Res;
elsif Current_Token = Tok_Inf then
-- FIXME: create node
Scan;
return Null_Node;
else
Error_Msg_Parse ("number expected");
return Null_Node;
end if;
end Parse_Number;
procedure Parse_Count (N : Node) is
begin
Set_Low_Bound (N, Parse_Number);
if Current_Token = Tok_To then
Scan;
Set_High_Bound (N, Parse_Number);
end if;
end Parse_Count;
function Psl_To_Vhdl (N : Node) return Iirs.Iir
is
use Iirs;
Res : Iir;
begin
case Get_Kind (N) is
when N_HDL_Expr =>
Res := Iirs.Iir (Get_HDL_Node (N));
Free_Node (N);
return Res;
when others =>
Error_Kind ("psl_to_vhdl", N);
end case;
end Psl_To_Vhdl;
function Vhdl_To_Psl (N : Iirs.Iir) return Node
is
Res : Node;
begin
Res := Create_Node_Loc (N_HDL_Expr);
Set_Location (Res, Iirs.Get_Location (N));
Set_HDL_Node (Res, Int32 (N));
return Res;
end Vhdl_To_Psl;
function Parse_FL_Property (Prio : Priority) return Node;
function Parse_Sequence return Node;
function Parse_Parenthesis_Boolean return Node;
function Parse_Boolean (Parent_Prio : Priority) return Node;
function Parse_Unary_Boolean return Node is
begin
return Vhdl_To_Psl (Parse.Parse_Expression);
end Parse_Unary_Boolean;
function Parse_Boolean_Rhs (Parent_Prio : Priority; Left : Node) return Node
is
Kind : Nkind;
Prio : Priority;
Res : Node;
Tmp : Node;
begin
Res := Left;
loop
case Current_Token is
when Tok_And =>
Kind := N_And_Bool;
Prio := Prio_Seq_And;
when Tok_Or =>
Kind := N_Or_Bool;
Prio := Prio_Seq_Or;
when others =>
return Res;
end case;
if Parent_Prio >= Prio then
return Res;
end if;
Tmp := Create_Node_Loc (Kind);
Scan;
Set_Left (Tmp, Res);
Res := Tmp;
Tmp := Parse_Boolean (Prio);
Set_Right (Res, Tmp);
end loop;
end Parse_Boolean_Rhs;
function Parse_Boolean (Parent_Prio : Priority) return Node
is
begin
return Parse_Boolean_Rhs (Parent_Prio, Parse_Unary_Boolean);
end Parse_Boolean;
function Parse_Psl_Boolean return PSL_Node is
begin
return Parse_Boolean (Prio_Lowest);
end Parse_Psl_Boolean;
function Parse_Parenthesis_Boolean return Node is
Res : Node;
begin
if Current_Token /= Tok_Left_Paren then
Error_Msg_Parse ("'(' expected before boolean expression");
return Null_Node;
else
Scan;
Res := Parse_Psl_Boolean;
if Current_Token = Tok_Right_Paren then
Scan;
else
Error_Msg_Parse ("missing matching ')' for boolean expression");
end if;
return Res;
end if;
end Parse_Parenthesis_Boolean;
function Parse_SERE (Prio : Priority) return Node is
Left, Res : Node;
Kind : Nkind;
Op_Prio : Priority;
begin
Left := Parse_Sequence; -- FIXME: allow boolean;
loop
case Current_Token is
when Tok_Semi_Colon =>
Kind := N_Concat_SERE;
Op_Prio := Prio_Seq_Concat;
when Tok_Colon =>
Kind := N_Fusion_SERE;
Op_Prio := Prio_Seq_Fusion;
when Tok_Within =>
Kind := N_Within_SERE;
Op_Prio := Prio_Seq_Within;
when Tok_Ampersand =>
-- For non-length matching and, the operator is '&'.
Kind := N_And_Seq;
Op_Prio := Prio_Seq_And;
when Tok_And_And =>
Kind := N_Match_And_Seq;
Op_Prio := Prio_Seq_And;
when Tok_Bar =>
Kind := N_Or_Seq;
Op_Prio := Prio_Seq_Or;
-- when Tok_Bar_Bar =>
-- Res := Create_Node_Loc (N_Or_Bool);
-- Scan;
-- Set_Left (Res, Left);
-- Set_Right (Res, Parse_Boolean (Prio_Seq_Or));
-- return Res;
when others =>
return Left;
end case;
if Prio >= Op_Prio then
return Left;
end if;
Res := Create_Node_Loc (Kind);
Scan;
Set_Left (Res, Left);
Set_Right (Res, Parse_SERE (Op_Prio));
Left := Res;
end loop;
end Parse_SERE;
-- precond : '{'
-- postcond: next token after '}'
function Parse_Braced_SERE return Node is
Res : Node;
begin
pragma Assert (Current_Token = Tok_Left_Curly);
Res := Create_Node_Loc (N_Braced_SERE);
-- Skip '{'
Scan;
Set_SERE (Res, Parse_SERE (Prio_Lowest));
if Current_Token /= Tok_Right_Curly then
Error_Msg_Parse ("missing '}' after braced SERE");
else
-- Skip '}'
Scan;
end if;
return Res;
end Parse_Braced_SERE;
-- Parse [ Count ] ']'
function Parse_Maybe_Count (Kind : Nkind; Seq : Node) return Node is
N : Node;
begin
N := Create_Node_Loc (Kind);
Set_Sequence (N, Seq);
Scan;
if Current_Token /= Tok_Right_Bracket then
Parse_Count (N);
end if;
if Current_Token /= Tok_Right_Bracket then
Error_Msg_Parse ("missing ']'");
else
Scan;
end if;
return N;
end Parse_Maybe_Count;
procedure Parse_Bracket_Range (N : Node) is
begin
if Current_Token /= Tok_Left_Bracket then
Error_Msg_Parse ("'[' expected");
else
Scan;
Set_Low_Bound (N, Parse_Number);
if Current_Token /= Tok_To then
Error_Msg_Parse ("'to' expected in range after left bound");
else
Scan;
Set_High_Bound (N, Parse_Number);
end if;
if Current_Token /= Tok_Right_Bracket then
Error_Msg_Parse ("']' expected after range");
else
Scan;
end if;
end if;
end Parse_Bracket_Range;
function Parse_Bracket_Number return Node is
Res : Node;
begin
if Current_Token /= Tok_Left_Bracket then
Error_Msg_Parse ("'[' expected");
return Null_Node;
else
Scan;
Res := Parse_Number;
if Current_Token /= Tok_Right_Bracket then
Error_Msg_Parse ("']' expected after range");
else
Scan;
end if;
return Res;
end if;
end Parse_Bracket_Number;
function Parse_Sequence return Node is
Res, N : Node;
begin
case Current_Token is
when Tok_Left_Curly =>
Res := Parse_Braced_SERE;
when Tok_Brack_Star =>
return Parse_Maybe_Count (N_Star_Repeat_Seq, Null_Node);
when Tok_Left_Paren =>
Res := Parse_Parenthesis_Boolean;
if Current_Token = Tok_Or
or else Current_Token = Tok_And
then
Res := Parse_Boolean_Rhs (Prio_Lowest, Res);
end if;
when Tok_Brack_Plus_Brack =>
Res := Create_Node_Loc (N_Plus_Repeat_Seq);
Scan;
return Res;
when others =>
-- Repeated_SERE
Res := Parse_Unary_Boolean;
end case;
loop
case Current_Token is
when Tok_Brack_Star =>
Res := Parse_Maybe_Count (N_Star_Repeat_Seq, Res);
when Tok_Brack_Plus_Brack =>
N := Create_Node_Loc (N_Plus_Repeat_Seq);
Set_Sequence (N, Res);
Scan;
Res := N;
when Tok_Brack_Arrow =>
Res := Parse_Maybe_Count (N_Goto_Repeat_Seq, Res);
when Tok_Brack_Equal =>
N := Create_Node_Loc (N_Equal_Repeat_Seq);
Set_Sequence (N, Res);
Scan;
Parse_Count (N);
if Current_Token /= Tok_Right_Bracket then
Error_Msg_Parse ("missing ']'");
else
Scan;
end if;
Res := N;
when others =>
return Res;
end case;
end loop;
end Parse_Sequence;
-- precond: '('
-- postcond: next token
function Parse_Parenthesis_FL_Property return Node is
Res : Node;
Loc : Location_Type;
begin
Loc := Get_Token_Location;
if Current_Token /= Tok_Left_Paren then
Error_Msg_Parse ("'(' expected around property");
return Parse_FL_Property (Prio_Lowest);
else
Scan;
Res := Parse_FL_Property (Prio_Lowest);
if Current_Token /= Tok_Right_Paren then
Error_Msg_Parse ("missing matching ')' for '(' at line "
& Image (Loc, False));
else
Scan;
end if;
return Res;
end if;
end Parse_Parenthesis_FL_Property;
-- Parse [ '!' ] '[' finite_Range ']' '(' FL_Property ')'
function Parse_Range_Property (K : Nkind) return Node is
Res : Node;
begin
Res := Create_Node_Loc (K);
Set_Strong_Flag (Res, Scan_Exclam_Mark);
Scan;
Parse_Bracket_Range (Res);
Set_Property (Res, Parse_Parenthesis_FL_Property);
return Res;
end Parse_Range_Property;
-- Parse [ '!' ] '(' Boolean ')' '[' Range ']' '(' FL_Property ')'
function Parse_Boolean_Range_Property (K : Nkind) return Node is
Res : Node;
begin
Res := Create_Node_Loc (K);
Set_Strong_Flag (Res, Scan_Exclam_Mark);
Scan;
Set_Boolean (Res, Parse_Parenthesis_Boolean);
Parse_Bracket_Range (Res);
Set_Property (Res, Parse_Parenthesis_FL_Property);
return Res;
end Parse_Boolean_Range_Property;
function Parse_FL_Property_1 return Node
is
Res : Node;
Tmp : Node;
begin
case Current_Token is
when Tok_Always =>
Res := Create_Node_Loc (N_Always);
Scan;
Set_Property (Res, Parse_FL_Property (Prio_FL_Invariance));
when Tok_Never =>
Res := Create_Node_Loc (N_Never);
Scan;
Set_Property (Res, Parse_FL_Property (Prio_FL_Invariance));
when Tok_Eventually =>
Res := Create_Node_Loc (N_Eventually);
if not Scan_Exclam_Mark then
Error_Msg_Parse ("'eventually' must be followed by '!'");
end if;
Scan;
Set_Property (Res, Parse_FL_Property (Prio_FL_Occurence));
when Tok_Next =>
Res := Create_Node_Loc (N_Next);
Scan;
if Current_Token = Tok_Left_Bracket then
Set_Number (Res, Parse_Bracket_Number);
Set_Property (Res, Parse_Parenthesis_FL_Property);
else
Set_Property (Res, Parse_FL_Property (Prio_FL_Occurence));
end if;
when Tok_Next_A =>
Res := Parse_Range_Property (N_Next_A);
when Tok_Next_E =>
Res := Parse_Range_Property (N_Next_E);
when Tok_Next_Event =>
Res := Create_Node_Loc (N_Next_Event);
Scan;
Set_Boolean (Res, Parse_Parenthesis_Boolean);
if Current_Token = Tok_Left_Bracket then
Set_Number (Res, Parse_Bracket_Number);
end if;
Set_Property (Res, Parse_Parenthesis_FL_Property);
when Tok_Next_Event_A =>
Res := Parse_Boolean_Range_Property (N_Next_Event_A);
when Tok_Next_Event_E =>
Res := Parse_Boolean_Range_Property (N_Next_Event_E);
when Tok_Left_Paren =>
return Parse_Parenthesis_FL_Property;
when Tok_Left_Curly =>
Res := Parse_Sequence;
if Get_Kind (Res) = N_Braced_SERE
and then Current_Token = Tok_Left_Paren
then
-- FIXME: must check that RES is really a sequence
-- (and not a SERE).
Tmp := Create_Node_Loc (N_Overlap_Imp_Seq);
Set_Sequence (Tmp, Res);
Set_Property (Tmp, Parse_Parenthesis_FL_Property);
Res := Tmp;
end if;
when others =>
Res := Parse_Sequence;
end case;
return Res;
end Parse_FL_Property_1;
function Parse_St_Binary_FL_Property (K : Nkind; Left : Node) return Node is
Res : Node;
begin
Res := Create_Node_Loc (K);
Set_Strong_Flag (Res, Scan_Exclam_Mark);
Set_Inclusive_Flag (Res, Scan_Underscore);
Scan;
Set_Left (Res, Left);
Set_Right (Res, Parse_FL_Property (Prio_FL_Bounding));
return Res;
end Parse_St_Binary_FL_Property;
function Parse_Binary_FL_Property (K : Nkind; Left : Node; Prio : Priority)
return Node
is
Res : Node;
begin
Res := Create_Node_Loc (K);
Scan;
Set_Left (Res, Left);
Set_Right (Res, Parse_FL_Property (Prio));
return Res;
end Parse_Binary_FL_Property;
function Parse_FL_Property (Prio : Priority) return Node
is
Res : Node;
N : Node;
begin
Res := Parse_FL_Property_1;
loop
case Current_Token is
when Tok_Minus_Greater =>
if Prio > Prio_Bool_Imp then
return Res;
end if;
N := Create_Node_Loc (N_Log_Imp_Prop);
Set_Left (N, Res);
Scan;
Set_Right (N, Parse_FL_Property (Prio_Bool_Imp));
Res := N;
when Tok_Bar_Arrow =>
if Prio > Prio_Seq_Imp then
return Res;
end if;
N := Create_Node_Loc (N_Overlap_Imp_Seq);
Set_Sequence (N, Res);
Scan;
Set_Property (N, Parse_FL_Property (Prio_Seq_Imp));
Res := N;
when Tok_Bar_Double_Arrow =>
if Prio > Prio_Seq_Imp then
return Res;
end if;
N := Create_Node_Loc (N_Imp_Seq);
Set_Sequence (N, Res);
Scan;
Set_Property (N, Parse_FL_Property (Prio_Seq_Imp));
Res := N;
when Tok_Abort =>
if Prio > Prio_FL_Abort then
return Res;
end if;
N := Create_Node_Loc (N_Abort);
Set_Property (N, Res);
Scan;
Set_Boolean (N, Parse_Boolean (Prio_Lowest));
-- Left associative.
return N;
when Tok_Exclam_Mark =>
N := Create_Node_Loc (N_Strong);
Set_Property (N, Res);
Scan;
Res := N;
when Tok_Until =>
if Prio > Prio_FL_Bounding then
return Res;
end if;
Res := Parse_St_Binary_FL_Property (N_Until, Res);
when Tok_Before =>
if Prio > Prio_FL_Bounding then
return Res;
end if;
Res := Parse_St_Binary_FL_Property (N_Before, Res);
when Tok_Or =>
if Prio > Prio_Seq_Or then
return Res;
end if;
Res := Parse_Binary_FL_Property (N_Or_Prop, Res, Prio_Seq_Or);
when Tok_And =>
if Prio > Prio_Seq_And then
return Res;
end if;
Res := Parse_Binary_FL_Property (N_And_Prop, Res, Prio_Seq_And);
when Token_Relational_Operator_Type =>
return Vhdl_To_Psl
(Parse.Parse_Relation_Rhs (Psl_To_Vhdl (Res)));
when Tok_Colon
| Tok_Bar
| Tok_Ampersand
| Tok_And_And =>
Error_Msg_Parse ("SERE operator '" & Image (Current_Token)
& "' is not allowed in property");
Scan;
N := Parse_FL_Property (Prio_Lowest);
return Res;
when Tok_Arobase =>
if Prio > Prio_Clock_Event then
return Res;
end if;
N := Create_Node_Loc (N_Clock_Event);
Set_Property (N, Res);
Scan;
Set_Boolean (N, Parse_Boolean (Prio_Clock_Event));
Res := N;
when others =>
return Res;
end case;
end loop;
end Parse_FL_Property;
function Parse_Psl_Property return PSL_Node is
begin
return Parse_FL_Property (Prio_Lowest);
end Parse_Psl_Property;
-- precond: identifier
-- postcond: ';'
--
-- 6.2.4.1 Property declaration
--
-- Property_Declaration ::=
-- PROPERTY psl_identifier [ ( Formal_Parameter_List ) ] DEF_SYM
-- property ;
function Parse_Psl_Declaration (Tok : Token_Type) return PSL_Node
is
Res : Node;
Param : Node;
Last_Param : Node;
Pkind : Nkind;
Kind : Nkind;
begin
case Tok is
when Tok_Psl_Property =>
Kind := N_Property_Declaration;
when Tok_Psl_Sequence =>
Kind := N_Sequence_Declaration;
when Tok_Psl_Endpoint =>
Kind := N_Endpoint_Declaration;
when others =>
raise Internal_Error;
end case;
Res := Create_Node_Loc (Kind);
if Current_Token = Tok_Identifier then
Set_Identifier (Res, Current_Identifier);
Scan;
end if;
-- Formal parameter list.
if Current_Token = Tok_Left_Paren then
Last_Param := Null_Node;
loop
-- precond: '(' or ';'.
Scan;
case Current_Token is
when Tok_Psl_Const =>
Pkind := N_Const_Parameter;
when Tok_Psl_Boolean =>
Pkind := N_Boolean_Parameter;
when Tok_Psl_Property =>
Pkind := N_Property_Parameter;
when Tok_Psl_Sequence =>
Pkind := N_Sequence_Parameter;
when others =>
Error_Msg_Parse ("parameter type expected");
end case;
-- Formal parameters.
loop
-- precond: parameter_type or ','
Scan;
Param := Create_Node_Loc (Pkind);
if Current_Token /= Tok_Identifier then
Error_Msg_Parse ("identifier for parameter expected");
else
Set_Identifier (Param, Current_Identifier);
end if;
if Last_Param = Null_Node then
Set_Parameter_List (Res, Param);
else
Set_Chain (Last_Param, Param);
end if;
Last_Param := Param;
Scan;
exit when Current_Token /= Tok_Comma;
end loop;
exit when Current_Token = Tok_Right_Paren;
if Current_Token /= Tok_Semi_Colon then
Error_Msg_Parse ("';' expected between formal parameter");
end if;
end loop;
Scan;
end if;
if Current_Token /= Tok_Is then
Error_Msg_Parse ("'is' expected after identifier");
else
-- Skip 'is'.
Scan;
end if;
case Kind is
when N_Property_Declaration =>
Set_Property (Res, Parse_Psl_Property);
when N_Sequence_Declaration
| N_Endpoint_Declaration =>
Set_Sequence (Res, Parse_Sequence);
when others =>
raise Internal_Error;
end case;
return Res;
end Parse_Psl_Declaration;
end Parse_Psl;
='n519' href='#n519'>519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
#
# Copyright (C) 2006-2012 OpenWrt.org
#
# This is free software, licensed under the GNU General Public License v2.
# See /LICENSE for more information.
#
BLOCK_MENU:=Block Devices
define KernelPackage/aoe
SUBMENU:=$(BLOCK_MENU)
TITLE:=ATA over Ethernet support
KCONFIG:=CONFIG_ATA_OVER_ETH
FILES:=$(LINUX_DIR)/drivers/block/aoe/aoe.ko
AUTOLOAD:=$(call AutoLoad,30,aoe)
endef
define KernelPackage/aoe/description
Kernel support for ATA over Ethernet
endef
$(eval $(call KernelPackage,aoe))
define KernelPackage/ata-core
SUBMENU:=$(BLOCK_MENU)
TITLE:=Serial and Parallel ATA support
DEPENDS:=@PCI_SUPPORT||TARGET_sunxi +kmod-scsi-core
KCONFIG:=CONFIG_ATA
FILES:=$(LINUX_DIR)/drivers/ata/libata.ko
ifneq ($(wildcard $(LINUX_DIR)/drivers/ata/libahci.ko),)
FILES+=$(LINUX_DIR)/drivers/ata/libahci.ko
endif
endef
$(eval $(call KernelPackage,ata-core))
define AddDepends/ata
SUBMENU:=$(BLOCK_MENU)
DEPENDS+=kmod-ata-core $(1)
endef
define KernelPackage/ata-ahci
TITLE:=AHCI Serial ATA support
KCONFIG:=CONFIG_SATA_AHCI
FILES:= \
$(LINUX_DIR)/drivers/ata/ahci.ko
AUTOLOAD:=$(call AutoLoad,41,libahci ahci,1)
$(call AddDepends/ata)
endef
define KernelPackage/ata-ahci/description
Support for AHCI Serial ATA controllers
endef
$(eval $(call KernelPackage,ata-ahci))
define KernelPackage/ata-ahci-platform
TITLE:=AHCI Serial ATA Platform support
KCONFIG:=CONFIG_SATA_AHCI_PLATFORM
FILES:= \
$(LINUX_DIR)/drivers/ata/ahci_platform.ko \
$(LINUX_DIR)/drivers/ata/libahci_platform.ko
AUTOLOAD:=$(call AutoLoad,40,libahci libahci_platform ahci_platform,1)
$(call AddDepends/ata,@TARGET_ipq806x||TARGET_mvebu||TARGET_sunxi)
endef
define KernelPackage/ata-ahci-platform/description
Platform support for AHCI Serial ATA controllers
endef
$(eval $(call KernelPackage,ata-ahci-platform))
define KernelPackage/ata-artop
TITLE:=ARTOP 6210/6260 PATA support
KCONFIG:=CONFIG_PATA_ARTOP
FILES:=$(LINUX_DIR)/drivers/ata/pata_artop.ko
AUTOLOAD:=$(call AutoLoad,41,pata_artop,1)
$(call AddDepends/ata)
endef
define KernelPackage/ata-artop/description
PATA support for ARTOP 6210/6260 host controllers
endef
$(eval $(call KernelPackage,ata-artop))
define KernelPackage/ata-imx
TITLE:=Freescale i.MX AHCI SATA support
DEPENDS:=@TARGET_imx6
KCONFIG:=\
CONFIG_AHCI_IMX \
CONFIG_SATA_AHCI_PLATFORM \
CONFIG_PATA_IMX=n
FILES:=$(LINUX_DIR)/drivers/ata/ahci_imx.ko
AUTOLOAD:=$(call AutoLoad,41,ahci_imx,1)
$(call AddDepends/ata)
endef
define KernelPackage/ata-imx/description
SATA support for the Freescale i.MX6 SoC's onboard AHCI SATA
endef
$(eval $(call KernelPackage,ata-imx))
define KernelPackage/ata-marvell-sata
TITLE:=Marvell Serial ATA support
KCONFIG:=CONFIG_SATA_MV
FILES:=$(LINUX_DIR)/drivers/ata/sata_mv.ko
AUTOLOAD:=$(call AutoLoad,41,sata_mv,1)
$(call AddDepends/ata)
endef
define KernelPackage/ata-marvell-sata/description
SATA support for marvell chipsets
endef
$(eval $(call KernelPackage,ata-marvell-sata))
define KernelPackage/ata-mvebu-ahci
TITLE:=Marvell EBU AHCI support
DEPENDS:=@TARGET_mvebu +kmod-ata-ahci-platform
KCONFIG:=CONFIG_AHCI_MVEBU
FILES:=$(LINUX_DIR)/drivers/ata/ahci_mvebu.ko
AUTOLOAD:=$(call AutoLoad,41,ahci_mvebu,1)
$(call AddDepends/ata)
endef
define KernelPackage/ata-mvebu-ahci/description
AHCI support for Marvell EBU SoCs
endef
$(eval $(call KernelPackage,ata-mvebu-ahci))
define KernelPackage/ata-nvidia-sata
TITLE:=Nvidia Serial ATA support
KCONFIG:=CONFIG_SATA_NV
FILES:=$(LINUX_DIR)/drivers/ata/sata_nv.ko
AUTOLOAD:=$(call AutoLoad,41,sata_nv,1)
$(call AddDepends/ata)
endef
$(eval $(call KernelPackage,ata-nvidia-sata))
define KernelPackage/ata-oxnas-sata
TITLE:=oxnas Serial ATA support
KCONFIG:=CONFIG_SATA_OXNAS
DEPENDS:=@TARGET_oxnas
FILES:=$(LINUX_DIR)/drivers/ata/sata_oxnas.ko
AUTOLOAD:=$(call AutoLoad,41,sata_oxnas,1)
$(call AddDepends/ata)
endef
define KernelPackage/ata-oxnas-sata/description
SATA support for OX934 core found in the OX82x/PLX782x SoCs
endef
$(eval $(call KernelPackage,ata-oxnas-sata))
define KernelPackage/ata-pdc202xx-old
SUBMENU:=$(BLOCK_MENU)
TITLE:=Older Promise PATA controller support
DEPENDS:=kmod-ata-core
KCONFIG:= \
CONFIG_ATA_SFF=y \
CONFIG_PATA_PDC_OLD
FILES:=$(LINUX_DIR)/drivers/ata/pata_pdc202xx_old.ko
AUTOLOAD:=$(call AutoLoad,41,pata_pdc202xx_old,1)
endef
define KernelPackage/ata-pdc202xx-old/description
This option enables support for the Promise 20246, 20262, 20263,
20265 and 20267 adapters
endef
$(eval $(call KernelPackage,ata-pdc202xx-old))
define KernelPackage/ata-piix
TITLE:=Intel PIIX PATA/SATA support
KCONFIG:=CONFIG_ATA_PIIX
FILES:=$(LINUX_DIR)/drivers/ata/ata_piix.ko
AUTOLOAD:=$(call AutoLoad,41,ata_piix,1)
$(call AddDepends/ata)
endef
define KernelPackage/ata-piix/description
SATA support for Intel ICH5/6/7/8 series host controllers and
PATA support for Intel ESB/ICH/PIIX3/PIIX4 series host controllers
endef
$(eval $(call KernelPackage,ata-piix))
define KernelPackage/ata-sil
TITLE:=Silicon Image SATA support
KCONFIG:=CONFIG_SATA_SIL
FILES:=$(LINUX_DIR)/drivers/ata/sata_sil.ko
AUTOLOAD:=$(call AutoLoad,41,sata_sil,1)
$(call AddDepends/ata)
endef
define KernelPackage/ata-sil/description
Support for Silicon Image Serial ATA controllers
endef
$(eval $(call KernelPackage,ata-sil))
define KernelPackage/ata-sil24
TITLE:=Silicon Image 3124/3132 SATA support
KCONFIG:=CONFIG_SATA_SIL24
FILES:=$(LINUX_DIR)/drivers/ata/sata_sil24.ko
AUTOLOAD:=$(call AutoLoad,41,sata_sil24,1)
$(call AddDepends/ata)
endef
define KernelPackage/ata-sil24/description
Support for Silicon Image 3124/3132 Serial ATA controllers
endef
$(eval $(call KernelPackage,ata-sil24))
define KernelPackage/ata-via-sata
TITLE:=VIA SATA support
KCONFIG:=CONFIG_SATA_VIA
FILES:=$(LINUX_DIR)/drivers/ata/sata_via.ko
AUTOLOAD:=$(call AutoLoad,41,sata_via,1)
$(call AddDepends/ata)
endef
define KernelPackage/ata-via-sata/description
This option enables support for VIA Serial ATA
endef
$(eval $(call KernelPackage,ata-via-sata))
define KernelPackage/block2mtd
SUBMENU:=$(BLOCK_MENU)
TITLE:=Block device MTD emulation
KCONFIG:=CONFIG_MTD_BLOCK2MTD
FILES:=$(LINUX_DIR)/drivers/mtd/devices/block2mtd.ko
endef
$(eval $(call KernelPackage,block2mtd))
define KernelPackage/dm
SUBMENU:=$(BLOCK_MENU)
TITLE:=Device Mapper
DEPENDS:=+kmod-crypto-manager
# All the "=n" are unnecessary, they're only there
# to stop the config from asking the question.
# MIRROR is M because I've needed it for pvmove.
KCONFIG:= \
CONFIG_BLK_DEV_MD=n \
CONFIG_DM_DEBUG=n \
CONFIG_DM_UEVENT=n \
CONFIG_DM_DELAY=n \
CONFIG_DM_LOG_WRITES=n \
CONFIG_DM_MQ_DEFAULT=n \
CONFIG_DM_MULTIPATH=n \
CONFIG_DM_ZERO=n \
CONFIG_DM_SNAPSHOT=n \
CONFIG_DM_LOG_USERSPACE=n \
CONFIG_MD=y \
CONFIG_BLK_DEV_DM \
CONFIG_DM_CRYPT \
CONFIG_DM_MIRROR
FILES:=$(LINUX_DIR)/drivers/md/dm-*.ko
AUTOLOAD:=$(call AutoLoad,30,dm-mod dm-log dm-region-hash dm-mirror dm-crypt)
endef
define KernelPackage/dm/description
Kernel module necessary for LVM2 support
endef
$(eval $(call KernelPackage,dm))
define KernelPackage/md-mod
SUBMENU:=$(BLOCK_MENU)
TITLE:=MD RAID
KCONFIG:= \
CONFIG_MD=y \
CONFIG_BLK_DEV_MD=m \
CONFIG_MD_AUTODETECT=y \
CONFIG_MD_FAULTY=n
FILES:=$(LINUX_DIR)/drivers/md/md-mod.ko
AUTOLOAD:=$(call AutoLoad,27,md-mod)
endef
define KernelPackage/md-mod/description
Kernel RAID md module (md-mod.ko).
You will need to select at least one RAID level module below.
endef
$(eval $(call KernelPackage,md-mod))
define KernelPackage/md/Depends
SUBMENU:=$(BLOCK_MENU)
DEPENDS:=kmod-md-mod $(1)
endef
define KernelPackage/md-linear
$(call KernelPackage/md/Depends,)
TITLE:=RAID Linear Module
KCONFIG:=CONFIG_MD_LINEAR
FILES:=$(LINUX_DIR)/drivers/md/linear.ko
AUTOLOAD:=$(call AutoLoad,28,linear)
endef
define KernelPackage/md-linear/description
RAID "Linear" or "Append" driver module (linear.ko)
endef
$(eval $(call KernelPackage,md-linear))
define KernelPackage/md-raid0
$(call KernelPackage/md/Depends,)
TITLE:=RAID0 Module
KCONFIG:=CONFIG_MD_RAID0
FILES:=$(LINUX_DIR)/drivers/md/raid0.ko
AUTOLOAD:=$(call AutoLoad,28,raid0)
endef
define KernelPackage/md-raid0/description
RAID Level 0 (Striping) driver module (raid0.ko)
endef
$(eval $(call KernelPackage,md-raid0))
define KernelPackage/md-raid1
$(call KernelPackage/md/Depends,)
TITLE:=RAID1 Module
KCONFIG:=CONFIG_MD_RAID1
FILES:=$(LINUX_DIR)/drivers/md/raid1.ko
AUTOLOAD:=$(call AutoLoad,28,raid1)
endef
define KernelPackage/md-raid1/description
RAID Level 1 (Mirroring) driver (raid1.ko)
endef
$(eval $(call KernelPackage,md-raid1))
define KernelPackage/md-raid10
$(call KernelPackage/md/Depends,)
TITLE:=RAID10 Module
KCONFIG:=CONFIG_MD_RAID10
FILES:=$(LINUX_DIR)/drivers/md/raid10.ko
AUTOLOAD:=$(call AutoLoad,28,raid10)
endef
define KernelPackage/md-raid10/description
RAID Level 10 (Mirroring+Striping) driver module (raid10.ko)
endef
$(eval $(call KernelPackage,md-raid10))
define KernelPackage/md-raid456
$(call KernelPackage/md/Depends,+kmod-lib-raid6 +kmod-lib-xor +LINUX_4_4:kmod-lib-crc32c)
TITLE:=RAID Level 456 Driver
KCONFIG:= \
CONFIG_ASYNC_CORE \
CONFIG_ASYNC_MEMCPY \
CONFIG_ASYNC_XOR \
CONFIG_ASYNC_PQ \
CONFIG_ASYNC_RAID6_RECOV \
CONFIG_ASYNC_RAID6_TEST=n \
CONFIG_MD_RAID456 \
CONFIG_MULTICORE_RAID456=n
FILES:= \
$(LINUX_DIR)/crypto/async_tx/async_tx.ko \
$(LINUX_DIR)/crypto/async_tx/async_memcpy.ko \
$(LINUX_DIR)/crypto/async_tx/async_xor.ko \
$(LINUX_DIR)/crypto/async_tx/async_pq.ko \
$(LINUX_DIR)/crypto/async_tx/async_raid6_recov.ko \
$(LINUX_DIR)/drivers/md/raid456.ko
AUTOLOAD:=$(call AutoLoad,28, async_tx async_memcpy async_xor async_pq async_raid6_recov raid456)
endef
define KernelPackage/md-raid456/description
RAID Level 4,5,6 kernel module (raid456.ko)
Includes the following modules required by
raid456.ko:
xor.ko
async_tx.ko
async_xor.ko
async_memcpy.ko
async_pq.ko
async_raid5_recov.ko
raid6_pq.ko
endef
$(eval $(call KernelPackage,md-raid456))
define KernelPackage/md-multipath
$(call KernelPackage/md/Depends,)
TITLE:=MD Multipath Module
KCONFIG:=CONFIG_MD_MULTIPATH
FILES:=$(LINUX_DIR)/drivers/md/multipath.ko
AUTOLOAD:=$(call AutoLoad,29,multipath)
endef
define KernelPackage/md-multipath/description
Multipath driver module (multipath.ko)
endef
$(eval $(call KernelPackage,md-multipath))
define KernelPackage/ide-core
SUBMENU:=$(BLOCK_MENU)
TITLE:=IDE (ATA/ATAPI) device support
DEPENDS:=@PCI_SUPPORT
KCONFIG:= \
CONFIG_IDE \
CONFIG_BLK_DEV_IDE \
CONFIG_BLK_DEV_IDEDISK \
CONFIG_IDE_GD \
CONFIG_IDE_GD_ATA=y \
CONFIG_IDE_GD_ATAPI=n \
CONFIG_IDEPCI_PCIBUS_ORDER=y \
CONFIG_BLK_DEV_IDEDMA_PCI=y \
CONFIG_BLK_DEV_IDEPCI=y
FILES:= \
$(LINUX_DIR)/drivers/ide/ide-core.ko \
$(LINUX_DIR)/drivers/ide/ide-gd_mod.ko
endef
define KernelPackage/ide-core/description
Kernel support for IDE, useful for usb mass storage devices (e.g. on WL-HDD)
Includes:
- ide-core
- ide-gd_mod
endef
$(eval $(call KernelPackage,ide-core))
define AddDepends/ide
SUBMENU:=$(BLOCK_MENU)
DEPENDS+=kmod-ide-core $(1)
endef
define KernelPackage/ide-generic
SUBMENU:=$(BLOCK_MENU)
DEPENDS:=@PCI_SUPPORT
TITLE:=Kernel support for generic PCI IDE chipsets
KCONFIG:=CONFIG_BLK_DEV_GENERIC
FILES:=$(LINUX_DIR)/drivers/ide/ide-pci-generic.ko
AUTOLOAD:=$(call AutoLoad,30,ide-pci-generic,1)
$(call AddDepends/ide)
endef
$(eval $(call KernelPackage,ide-generic))
define KernelPackage/ide-generic-old
SUBMENU:=$(BLOCK_MENU)
TITLE:=Kernel support for generic (legacy) IDE chipsets
KCONFIG:=CONFIG_IDE_GENERIC
FILES:=$(LINUX_DIR)/drivers/ide/ide-generic.ko
AUTOLOAD:=$(call AutoLoad,30,ide-generic,1)
$(call AddDepends/ide)
endef
$(eval $(call KernelPackage,ide-generic-old))
define KernelPackage/ide-aec62xx
TITLE:=Acard AEC62xx IDE driver
DEPENDS:=@PCI_SUPPORT
KCONFIG:=CONFIG_BLK_DEV_AEC62XX
FILES:=$(LINUX_DIR)/drivers/ide/aec62xx.ko
AUTOLOAD:=$(call AutoLoad,30,aec62xx,1)
$(call AddDepends/ide)
endef
define KernelPackage/ide-aec62xx/description
Support for Acard AEC62xx (Artop ATP8xx) IDE controllers
endef
$(eval $(call KernelPackage,ide-aec62xx,1))
define KernelPackage/ide-pdc202xx
TITLE:=Promise PDC202xx IDE driver
DEPENDS:=@PCI_SUPPORT
KCONFIG:=CONFIG_BLK_DEV_PDC202XX_OLD
FILES:=$(LINUX_DIR)/drivers/ide/pdc202xx_old.ko
AUTOLOAD:=$(call AutoLoad,30,pdc202xx_old,1)
$(call AddDepends/ide)
endef
define KernelPackage/ide-pdc202xx/description
Support for the Promise Ultra 33/66/100 (PDC202{46|62|65|67|68}) IDE
controllers.
endef
$(eval $(call KernelPackage,ide-pdc202xx))
define KernelPackage/ide-it821x
TITLE:=ITE IT821x IDE driver
DEPENDS:=@PCI_SUPPORT
KCONFIG:=CONFIG_BLK_DEV_IT821X
FILES=$(LINUX_DIR)/drivers/ide/it821x.ko
AUTOLOAD:=$(call AutoLoad,30,it821x,1)
$(call AddDepends/ide)
endef
define KernelPackage/ide-it821x/description
Kernel module for the ITE IDE821x IDE controllers
endef
$(eval $(call KernelPackage,ide-it821x))
define KernelPackage/libsas
SUBMENU:=$(BLOCK_MENU)
DEPENDS:=@TARGET_x86
TITLE:=SAS Domain Transport Attributes
KCONFIG:=CONFIG_SCSI_SAS_LIBSAS \
CONFIG_SCSI_SAS_ATTRS \
CONFIG_SCSI_SAS_ATA=y \
CONFIG_SCSI_SAS_HOST_SMP=y \
CONFIG_SCSI_SAS_LIBSAS_DEBUG=y
FILES:= \
$(LINUX_DIR)/drivers/scsi/scsi_transport_sas.ko \
$(LINUX_DIR)/drivers/scsi/libsas/libsas.ko
AUTOLOAD:=$(call AutoLoad,29,scsi_transport_sas libsas,1)
endef
define KernelPackage/libsas/description
SAS Domain Transport Attributes support
endef
$(eval $(call KernelPackage,libsas,1))
define KernelPackage/loop
SUBMENU:=$(BLOCK_MENU)
TITLE:=Loopback device support
KCONFIG:= \
CONFIG_BLK_DEV_LOOP \
CONFIG_BLK_DEV_CRYPTOLOOP=n
FILES:=$(LINUX_DIR)/drivers/block/loop.ko
AUTOLOAD:=$(call AutoLoad,30,loop)
endef
define KernelPackage/loop/description
Kernel module for loopback device support
endef
$(eval $(call KernelPackage,loop))
define KernelPackage/mvsas
SUBMENU:=$(BLOCK_MENU)
TITLE:=Marvell 88SE6440 SAS/SATA driver
DEPENDS:=@TARGET_x86 +kmod-libsas
KCONFIG:= \
CONFIG_SCSI_MVSAS \
CONFIG_SCSI_MVSAS_TASKLET=n
FILES:=$(LINUX_DIR)/drivers/scsi/mvsas/mvsas.ko
AUTOLOAD:=$(call AutoLoad,40,mvsas,1)
endef
define KernelPackage/mvsas/description
Kernel support for the Marvell SAS SCSI adapters
endef
$(eval $(call KernelPackage,mvsas))
define KernelPackage/nbd
SUBMENU:=$(BLOCK_MENU)
TITLE:=Network block device support
KCONFIG:=CONFIG_BLK_DEV_NBD
FILES:=$(LINUX_DIR)/drivers/block/nbd.ko
AUTOLOAD:=$(call AutoLoad,30,nbd)
endef
define KernelPackage/nbd/description
Kernel module for network block device support
endef
$(eval $(call KernelPackage,nbd))
define KernelPackage/scsi-core
SUBMENU:=$(BLOCK_MENU)
TITLE:=SCSI device support
KCONFIG:= \
CONFIG_SCSI \
CONFIG_BLK_DEV_SD
FILES:= \
$(LINUX_DIR)/drivers/scsi/scsi_mod.ko \
$(LINUX_DIR)/drivers/scsi/sd_mod.ko
AUTOLOAD:=$(call AutoLoad,40,scsi_mod sd_mod,1)
endef
$(eval $(call KernelPackage,scsi-core))
define KernelPackage/scsi-generic
SUBMENU:=$(BLOCK_MENU)
TITLE:=Kernel support for SCSI generic
DEPENDS:=+kmod-scsi-core
KCONFIG:= \
CONFIG_CHR_DEV_SG
FILES:= \
$(LINUX_DIR)/drivers/scsi/sg.ko
AUTOLOAD:=$(call AutoLoad,65,sg)
endef
$(eval $(call KernelPackage,scsi-generic))
define KernelPackage/scsi-cdrom
SUBMENU:=$(BLOCK_MENU)
TITLE:=Kernel support for CD / DVD drives
DEPENDS:=+kmod-scsi-core
KCONFIG:= \
CONFIG_BLK_DEV_SR \
CONFIG_BLK_DEV_SR_VENDOR=n
FILES:= \
$(LINUX_DIR)/drivers/cdrom/cdrom.ko \
$(LINUX_DIR)/drivers/scsi/sr_mod.ko
AUTOLOAD:=$(call AutoLoad,45,sr_mod)
endef
$(eval $(call KernelPackage,scsi-cdrom))
define KernelPackage/scsi-tape
SUBMENU:=$(BLOCK_MENU)
TITLE:=Kernel support for scsi tape drives
DEPENDS:=+kmod-scsi-core
KCONFIG:= \
CONFIG_CHR_DEV_ST
FILES:= \
$(LINUX_DIR)/drivers/scsi/st.ko
AUTOLOAD:=$(call AutoLoad,45,st)
endef
$(eval $(call KernelPackage,scsi-tape))
|