हाल ही में, हार्डवेयर की लागत के बिना RISC-V वास्तुकला के साथ प्रयोग करने के तरीके पर एक लेख प्रकाशित किया गया था । लेकिन क्या होगा अगर आप डिबग बोर्ड पर ऐसा करते हैं? याद रखें कि गेम जनरेटर के बारे में मेमर्स: "ग्राफिक्स की शैली में 20 चेकमार्क क्राइसिस से बदतर नहीं हैं", "आप कोरोवान को लूट सकते हैं" और "जेनरेट" बटन। RocketChip SoC जनरेटर लगभग उसी तरह से व्यवस्थित किया गया है, केवल चेकमार्क वाली एक खिड़की नहीं है, बल्कि एक स्काला कोड और कोडांतरक और मेक फ़ाइलों का एक सा है। इस लेख में, मैं दिखाऊंगा कि इस रॉकेटशिप को अपने मूल Xilinx से Altera / Intel में पोर्ट करना कितना आसान है।

अस्वीकरण: लेखक "जला" बोर्ड के लिए ज़िम्मेदार नहीं है - ध्यान से देखें कि आप पिन कैसे कॉन्फ़िगर करते हैं, आप शारीरिक रूप से क्या कनेक्ट करते हैं, आदि। खैर, सुरक्षा सावधानियों का भी पालन करें। आपको यह नहीं सोचना चाहिए कि चूंकि सब कुछ यूएसबी के माध्यम से जुड़ा हुआ है, तो यह निश्चित रूप से एक व्यक्ति के लिए सुरक्षित है: जैसा कि मैंने अपने पिछले प्रयोगों में समझा था, भले ही आप यूएसबी-बोर्ड के साथ काम करते हों, फिर भी आपको अपने पैर के साथ हीटिंग बैटरी को छूने की ज़रूरत नहीं है, क्योंकि संभावित अंतर ... ओह हां , मैं लगभग एक पेशेवर plisovods या इलेक्ट्रॉनिक इंजीनियर नहीं हूँ - मैं सिर्फ एक स्काला प्रोग्रामर हूँ।

जहां तक ​​मैं समझता हूं, रॉकेटसेट को डिबग करने का प्रारंभिक मंच एक्सिलिनएक्स एफपीजीए था। रिपॉजिटरी को देखते हुए, जिसे हम जल्द ही क्लोन कर रहे हैं, इसे माइक्रोसेमी में भी रखा गया था। कहीं मैंने एल्टर के उपयोग के बारे में सुना है, लेकिन स्रोत नहीं देखा। जैसा कि यह पता चला है, यह एक बड़ी समस्या नहीं है: जिस क्षण से हमने बोर्ड प्राप्त किया और कार्यशील " मेमोरीलेस " के लिए SiFive फ्रीडम रिपॉजिटरी का अध्ययन करना शुरू कर दिया (यानी, केवल प्रोसेसर रजिस्टर, बूटमॉम और मेमोरी मैप्ड रजिस्टर, 32-बिट "माइक्रोकंट्रोलर"), हालांकि यह पहले से ही है कुछ नैनोकंट्रोलर निकलता है ...) 3 दिन की छुट्टी और 4 वीकेंड्स बीत चुके हैं, और अगर विश्व स्तर पर SYNTHESIS को परिभाषित करने के लिए तुरंत मेरे पास आया तो इसे और भी कम ले लिया होगा।

सामग्री

शुरुआत के लिए - शब्द के व्यापक अर्थ में सामग्री की एक सूची। हमें निम्नलिखित सॉफ्टवेयर की आवश्यकता है:

• रॉकेटशिप - इसमें स्वयं प्रोसेसर और असेंबली वातावरण शामिल है (सहित, कई उप-रिपॉजिटरी का वर्णन करता है)। रॉकेट कोर इन-ऑर्डर प्रोसेसर के साथ रॉकेटशिप बनाने में सक्षम।
• SiFive स्वतंत्रता - विभिन्न डिबग बोर्डों के लिए बाध्यकारी - वहां हम अपने लिए समर्थन जोड़ देंगे
• रॉकेट-टूल्स - 32- और 64-बिट आरआईएससी-वी आर्किटेक्चर के लिए कोड बनाने और डिबगिंग के लिए उपकरण
• Openocd-riscv - RISC-V गुठली (कम से कम RocketChip) के साथ JTAG पर काम करने के लिए OpenOCD पोर्ट
• स्काला कोड के संपादन के लिए IntelliJ IDEA समुदाय , जो कि RocketChip में बहुमत है
• SiFive के पूर्व-इकट्ठे टूलचैन भी काम में आ सकते हैं, एक लिंक जो मैंने पहले ही उल्लेख किए गए लेख में देखा था

लोहे से क्या आवश्यक है:

• Aliexpress से ज़ियोवा किट: साइक्लोन 4 EP4CE115 और (क्लोन?) USB ब्लास्टर के साथ बोर्ड
• सॉफ्ट कोर के लिए JTAG डिबगर के रूप में रास्पबेरीपी

होस्ट मशीन को एक अपेक्षाकृत शक्तिशाली कंप्यूटर माना जाता है जिसमें उबंटू और क्वार्टस लाइट 18 स्थापित है।

दरअसल, फायरफिम नामक एक ही SiFive से उनके FPGA- उदाहरणों पर अमेज़ॅन क्लाउड में लॉन्च करने का विकल्प है, लेकिन यह इतना दिलचस्प नहीं है, हां, और एलईडी खराब दिखाई दे रहे हैं । इसके अलावा, इस मामले में, आपको अन्य वर्चुअल मशीनों को लॉन्च करने के लिए कंट्रोल उदाहरण पर अपनी एपीआई कुंजी को निर्दिष्ट करने की आवश्यकता होगी, और आपको इसकी बहुत देखभाल करने की आवश्यकता है, अन्यथा यह अफवाह है कि आप एक दिन में हजारों डॉलर के ऋण के साथ जाग सकते हैं ...

हम स्थिति का अध्ययन करते हैं

आरंभ करने के लिए, मैंने बोर्ड विक्रेता से read_write_1G परीक्षण परियोजना ली और read_write_1G आवश्यक स्रोतों को जोड़ने का प्रयास किया। नया क्यों नहीं बनाया? क्योंकि मैं नया हूँ, और इस परियोजना में पिंस के नाम पहले से ही मैप किए गए हैं। इसलिए, आपको कहीं से सोर्स कोड लेने की आवश्यकता है। ऐसा करने के लिए, हमें पहले से निर्दिष्ट freedom भंडार ( freedom-e-sdk साथ भ्रमित नहीं होना) की आवश्यकता होगी। कम से कम कुछ प्राप्त करने के लिए, हम निर्देशों के अनुसार rocket-tools एकत्र करेंगे (शाब्दिक रूप से दो लिपियों और बहुत प्रतीक्षा की शुरूआत), और फिर चलाएं

 RISCV=$(pwd)/../rocket-tools make -f Makefile.e300artydevkit verilog mcs 

लक्ष्य verilog हमारे लिए प्रोसेसर स्रोतों के साथ एक विशाल Verilog फ़ाइल उत्पन्न verilog , और mcs BootROM mcs संकलित करेगा। चिंता न करें कि mcs विफल हो जाता है - हमारे पास केवल Xilinx Vivado नहीं है, इसलिए संकलित BootROM को उस प्रारूप में परिवर्तित नहीं किया जा सकता है, जिसे Vivado की आवश्यकता है।

मेनू आइटम Quartus प्रोजेक्ट के माध्यम से -> प्रोजेक्ट में फ़ाइलें जोड़ें / निकालें ... freedom/builds/e300artydevkit/sifive.freedom.everywhere.e300artydevkit.E300ArtyDevKitConfig.v जोड़ें freedom/builds/e300artydevkit/sifive.freedom.everywhere.e300artydevkit.E300ArtyDevKitConfig.v , शीर्ष स्तर की इकाई सेट करें: E300ArtyDevitKPGFPGPPG पर चालू करें। शीर्ष स्तर की इकाई स्वतः पूर्ण होने वाली सूची पहले संकलन के बाद दिखाई देगी)। परिणामस्वरूप, हमें AsyncResetReg , IOBUF मॉड्यूल, आदि की अनुपस्थिति के बारे में बताने के लिए बहुत सारी त्रुटियां AsyncResetReg । यदि कोई त्रुटि नहीं है, तो आप शीर्ष स्तर की इकाई को बदलना भूल गए। यदि आप स्रोत के माध्यम से AsyncResetReg.v करते हैं, तो आप सीधे AsyncResetReg.v फ़ाइल पा सकते हैं, लेकिन IOBUF Xilinx के IP कोर के लिए एक बाध्यकारी है। सबसे पहले, freedom/rocket-chip/src/main/resources/vsrc/AsyncResetReg.v । और plusarg_reader.v को भी जोड़ा जाएगा।

संकलन चलाएं और एक और त्रुटि प्राप्त करें:

 Error (10174): Verilog HDL Unsupported Feature error at plusarg_reader.v(18): system function "$value$plusargs" is not supported for synthesis 

सिद्धांत रूप में, गैर-संश्लेषित निर्माणों को एक समान नाम वाली फ़ाइल से उम्मीद की जा सकती है।

 // See LICENSE.SiFive for license details. //VCS coverage exclude_file // No default parameter values are intended, nor does IEEE 1800-2012 require them (clause A.2.4 param_assignment), // but Incisive demands them. These default values should never be used. module plusarg_reader #(parameter FORMAT="borked=%d", DEFAULT=0) ( output [31:0] out ); `ifdef SYNTHESIS assign out = DEFAULT; `else reg [31:0] myplus; assign out = myplus; initial begin if (!$value$plusargs(FORMAT, myplus)) myplus = DEFAULT; end `endif endmodule 

जैसा कि हम देख सकते हैं, यह मॉड्यूल संभवतः कमांड लाइन से सिमुलेशन विकल्प पढ़ता है, और जब इसे संश्लेषित करता है तो बस डिफ़ॉल्ट मान देता है। समस्या यह है कि हमारी परियोजना SYNTHESIS नाम से परिभाषित नहीं है। ifdef से ठीक पहले पिछली पंक्ति पर `define SYNTHESIS को `define SYNTHESIS करना संभव है, और फिर आधा सप्ताह यह समझने की कोशिश में बिताएं कि कर्नेल शुरू नहीं होता है (और आखिरकार, संक्रमण संश्लेषित है ...)। मेरी गलतियों को न दोहराएं, लेकिन बस प्रोजेक्ट गुणों को फिर से खोलें, और कंपाइलर सेटिंग्स पर-> वेरिलॉग एचडीएल इनपुट टैब, SYNTHESIS मैक्रो को परिभाषित करें, और कम से कम 1, <NONE> (खाली लाइन) में नहीं।

यहाँ! अब क्वार्टस लापता बाइंडिंग पर शपथ लेता है - आइडिया में एक परियोजना स्थापित करने और पोर्टिंग शुरू करने का समय है।

परियोजना को जानना

हम आयात परियोजना के विचार को बताते हैं, freedom भंडार को पथ निर्दिष्ट करते हैं, sbt परियोजना के प्रकार को इंगित करते हैं, चेकबॉक्स के निर्माण के लिए, आयात के लिए उपयोग sbt शेल की जांच करते हैं। यहां, परी कथा समाप्त होती है, ऐसा प्रतीत होता है, लेकिन यह एक आधे-प्रोजेक्ट के विचार को नहीं खोजता है - सभी स्रोत कोड लाल रंग में चिह्नित हैं। यहाँ से मिली जानकारी के आधार पर, मुझे निम्नलिखित प्रक्रिया मिली:

• sbt शेल विंडो खोलें
• clean प्रवेश करें
• बाईं ओर हरे रंग का पुनरारंभ बटन दबाएँ
• sbt को पुनरारंभ करने के बाद, पहले कमांड ++2.12.4 दर्ज करें, जिससे सभी सबप्रोजेक्ट्स को Scala वर्जन 2.12.4 पर स्विच कर दें, फिर हम compile चलाएंगे
• सभी sbt प्रोजेक्ट आइडिया को ताज़ा करें पर क्लिक करें
• लाभ!, अब backlight सही ढंग से काम करता है

अब तक, मैं किसी भी तरह परियोजना को इकट्ठा करने की कोशिश करूंगा, कम से कम अर्ध-मैनुअल मोड में। वैसे, कोई quartus_ipcreate बताओ, लाइट संस्करण में quartus_ipcreate है? हम अभी के लिए मैन्युअल रूप से आईपी वेरिएशन बनाएंगे, और बाइंडिंग केवल ब्लैकबॉक्स के रूप में स्काला पर होगी।

इस मामले में, हम निम्नलिखित निर्देशिका पदानुक्रम में रुचि रखते हैं:

 fpga-shells () | +-src/main/scala | +- ip/intel <--     IP Variations | | | +- Intel.scala | +- shell/intel <--       | +- ZeowaaShell.scala src/main/scala | +- everywhere.e300artydevkit <--   "" ,    | +- zeowaa/e115 <--      "" SoC | +- Config +- FPGAChip +- Platform +- System 

आपको Makefile.e300artydevkit के समान एक मेकफाइल भी जोड़ना होगा, कुछ इस तरह से:

Makefile.zeowaa-e115:

 # See LICENSE for license details. base_dir := $(patsubst %/,%,$(dir $(abspath $(lastword $(MAKEFILE_LIST))))) BUILD_DIR := $(base_dir)/builds/zeowaa-e115 FPGA_DIR := $(base_dir)/fpga-shells/intel MODEL := FPGAChip PROJECT := sifive.freedom.zeowaa.e115 export CONFIG_PROJECT := sifive.freedom.zeowaa.e115 export CONFIG := ZeowaaConfig export BOARD := zeowaa export BOOTROM_DIR := $(base_dir)/bootrom/xip rocketchip_dir := $(base_dir)/rocket-chip sifiveblocks_dir := $(base_dir)/sifive-blocks include common.mk 

बाइंडिंग

शुरू करने के लिए, हम इस IOBUF लागू करते हैं - यह शायद ही मुश्किल होगा। स्काला कोड को देखते हुए, यह एक ऐसा मॉड्यूल है जो भौतिक "लेग" (बॉल?) को माइक्रोक्रिकिट पर नियंत्रित करता है: इसे चालू किया जा सकता है, चालू किया जा सकता है या पूरी तरह से बंद किया जा सकता है। क्वार्टस विंडो के दाहिने हिस्से में, हम "IOBUF" आईपी कैटलॉग में प्रवेश करेंगे, और तुरंत ALTIOBUF नामक एक घटक प्राप्त ALTIOBUF । चलो विविधता फ़ाइल के लिए कुछ नाम निर्धारित करते हैं, "एक द्विदिश बफर के रूप में" चुनें। उसके बाद, हमारे प्रोजेक्ट में iobuf नामक एक मॉड्यूल दिखाई देगा:

 // ... module obuf ( datain, oe, dataout); input [0:0] datain; input [0:0] oe; output [0:0] dataout; wire [0:0] sub_wire0; wire [0:0] dataout = sub_wire0[0:0]; obuf_iobuf_out_d5t obuf_iobuf_out_d5t_component ( .datain (datain), .oe (oe), .dataout (sub_wire0)); endmodule // ... 

आइए इसके लिए एक ब्लैकबॉक्स मॉड्यूल लिखें:

 package ip.intel import chisel3._ import chisel3.core.{Analog, BlackBox} import freechips.rocketchip.jtag.Tristate class IOBUF extends BlackBox { val io = IO(new Bundle { val datain = Input(Bool()) val dataout = Output(Bool()) val oe = Input(Bool()) val dataio = Analog(1.W) }) override def desiredName: String = "iobuf" } object IOBUF { def apply(a: Analog, t: Tristate): IOBUF = { val res = Module(new IOBUF) res.io.datain := t.data res.io.oe := t.driven a <> res.io.dataio res } } 

हम टाइप Analog के वेरिलोग इनआउट का वर्णन करते हैं, और desiredName विधि desiredName मॉड्यूल का वर्ग नाम बदलने की अनुमति देती है। यह विशेष रूप से महत्वपूर्ण है क्योंकि हम बाइंडर्स उत्पन्न करते हैं, कार्यान्वयन नहीं।

हमें BootROM की भी आवश्यकता है - इसके लिए हम ROM: 1-PORT (2048 x 32-बिट शब्द, केवल एड्रेस रजिस्टर, rden पोर्ट बनाएँ) की भिन्नता बनाएँ। हम नाम के साथ एक ब्लॉक बनाते हैं rom , क्योंकि तब हमें इंटरफ़ेस के लिए एक एडेप्टर लिखना होगा जो ROMGenerator वर्ग को ROMGenerator : me बजाय ROMGenerator और हमसे गायब (यह अभी भी 1 से जुड़ा हुआ है):

BootROM.v:

 module BootROM( input wire [10:0] address, input wire clock, input wire me, input wire oe, output wire [31:0] q ); rom r( .address(address), .clock(clock), .rden(me), .q(q) ); endmodule 

एक और समस्या का तुरंत पता लगाया जाता है: कलेक्टर द्वारा उत्पन्न हेक्स-फाइलें, किसी कारण से, क्वार्ट्स के साथ असंगत होना। इंटेल हेक्स फ़ाइलों के विषय पर एक हल्की गुगली करने के बाद (इंटेल इस इंटेल एल्टर की खरीद से बहुत पहले था, जैसा कि मैं इसे समझता हूं), हम ऐसे कमांड में आते हैं जो बाइनरी फ़ाइलों को एचईएक्स में परिवर्तित करता है:

 srec_cat -Output builds/zeowaa-e115/xip.hex -Intel builds/zeowaa-e115/xip.bin -Binary -Output_Block_Size 128 

इसलिए, हमारा मेकफाइल थोड़ा बदल जाएगा:

 base_dir := $(patsubst %/,%,$(dir $(abspath $(lastword $(MAKEFILE_LIST))))) BUILD_DIR := $(base_dir)/builds/zeowaa-e115 FPGA_DIR := $(base_dir)/fpga-shells/intel MODEL := FPGAChip PROJECT := sifive.freedom.zeowaa.e115 export CONFIG_PROJECT := sifive.freedom.zeowaa.e115 export CONFIG := ZeowaaConfig export BOARD := zeowaa export BOOTROM_DIR := $(base_dir)/bootrom/xip rocketchip_dir := $(base_dir)/rocket-chip sifiveblocks_dir := $(base_dir)/sifive-blocks all: verilog $(MAKE) -C $(BOOTROM_DIR) clean romgen || true srec_cat -Output $(BUILD_DIR)/xip.hex -Intel $(BUILD_DIR)/xip.bin -Binary -Output_Block_Size 128 include common.mk 

यह चलता है ^ W संश्लेषित है

तो, एक पूरे के रूप में परियोजना को संश्लेषित किया जाता है, अब सबसे दिलचस्प बात डिबगिंग है। बिल्ली को पहले घर में अनुमति दी जाती है, और शायद JTAG को माइक्रोकंट्रोलर में। डिबगिंग के लिए लगभग न्यूनतम सिस्टम बनाते हैं: बूट से बूट, जीपीआईओ से एलईडी को ब्लिंक करने के लिए, और जेटीएजी यह समझने के लिए कि क्यों कुछ भी लोड नहीं हो रहा है और ब्लिंकिंग नहीं। E300ArtyDevKit साथ सादृश्य करके E300ArtyDevKit इसमें चार फ़ाइलों के साथ एक पैकेज बनाएँ। सबसे पहले,

Config.scala:

 class DefaultZeowaaConfig extends Config ( new WithNBreakpoints(2) ++ new WithNExtTopInterrupts(0) ++ new WithJtagDTM ++ new TinyConfig ) class Peripherals extends Config((site, here, up) => { case PeripheryGPIOKey => List( GPIOParams(address = BigInt(0x64002000L), width = 6) ) case PeripheryMaskROMKey => List( MaskROMParams(address = 0x10000, name = "BootROM")) }) class ZeowaaConfig extends Config( new Peripherals ++ new DefaultZeowaaConfig().alter((site, here, up) => { case JtagDTMKey => new JtagDTMConfig ( idcodeVersion = 2, idcodePartNum = 0xe31, idcodeManufId = 0x489, debugIdleCycles = 5) }) ) 

विवरण E300 से कॉपी किए गए और काटे गए अधिकांश भाग के लिए है: हम पूछते हैं कि हमारे कर्नेल में क्या है और यह पता स्थान में कहां होगा। कृपया ध्यान दें कि हालांकि हमारे पास RAM नहीं है (यह TinyConfig में डिफ़ॉल्ट TinyConfig है), एक पता स्थान, इसके अलावा, 32-बिट है!

एक फ़ाइल भी है जो बॉयलरप्लेट की एक निश्चित मात्रा को वहन करती है।
System.scala:

 class System(implicit p: Parameters) extends RocketSubsystem with HasPeripheryMaskROMSlave with HasPeripheryDebug with HasPeripheryGPIO { override lazy val module = new SystemModule(this) } class SystemModule[+L <: System](_outer: L) extends RocketSubsystemModuleImp(_outer) with HasPeripheryDebugModuleImp with HasPeripheryGPIOModuleImp { // Reset vector is set to the location of the mask rom val maskROMParams = p(PeripheryMaskROMKey) global_reset_vector := maskROMParams(0).address.U } 

दरअसल, हमारे "मदरबोर्ड" का लेआउट तीन (अब तक) सरल फाइलों में है:
Platform.scala:

 class PlatformIO(implicit val p: Parameters) extends Bundle { val jtag = Flipped(new JTAGIO(hasTRSTn = false)) val jtag_reset = Input(Bool()) val gpio = new GPIOPins(() => new BasePin(), p(PeripheryGPIOKey)(0)) } class Platform(implicit p: Parameters) extends Module { val sys = Module(LazyModule(new System).module) override val io = IO(new PlatformIO) val sjtag = sys.debug.systemjtag.get sjtag.reset := io.jtag_reset sjtag.mfr_id := p(JtagDTMKey).idcodeManufId.U(11.W) sjtag.jtag <> io.jtag io.gpio <> sys.gpio.head } 

FPGAChip.scala:

 class FPGAChip(override implicit val p: Parameters) extends ZeowaaShell { withClockAndReset(cpu_clock, cpu_rst) { val dut = Module(new Platform) dut.io.jtag.TCK := jtag_tck dut.io.jtag.TDI := jtag_tdi IOBUF(jtag_tdo, dut.io.jtag.TDO) dut.io.jtag.TMS := jtag_tms dut.io.jtag_reset := jtag_rst Seq(led_0, led_1, led_2, led_3) zip dut.io.gpio.pins foreach { case (led, pin) => led := Mux(pin.o.oe, pin.o.oval, false.B) } dut.io.gpio.pins.foreach(_.i.ival := false.B) dut.io.gpio.pins(4).i.ival := key1 dut.io.gpio.pins(5).i.ival := key2 } } 

जैसा कि आप देख सकते हैं, आप एक कार्यात्मक शैली में चिसेल में जनरेटर लिख सकते हैं (एक बहुत ही सरल मामला यहां दिखाया गया है)। लेकिन आप लिख सकते हैं और स्पष्ट रूप से हर तार:

 object ZeowaaShell { class MemIf extends Bundle { val mem_addr = IO(Analog(14.W)) val mem_ba = IO(Analog(3.W)) val mem_cas_n = IO(Analog(1.W)) val mem_cke = IO(Analog(2.W)) val mem_clk = IO(Analog(2.W)) val mem_clk_n = IO(Analog(2.W)) val mem_cs_n = IO(Analog(2.W)) val mem_dm = IO(Analog(8.W)) val mem_dq = IO(Analog(64.W)) val mem_dqs = IO(Analog(8.W)) val mem_odt = IO(Analog(2.W)) val mem_ras_n = IO(Analog(1.W)) val mem_we_n = IO(Analog(1.W)) } } class ZeowaaShell(implicit val p: Parameters) extends RawModule { val clk25 = IO(Input(Clock())) val clk27 = IO(Input(Clock())) val clk48 = IO(Input(Clock())) val key1 = IO(Input(Bool())) val key2 = IO(Input(Bool())) val key3 = IO(Input(Bool())) val led_0 = IO(Output(Bool())) val led_1 = IO(Output(Bool())) val led_2 = IO(Output(Bool())) val led_3 = IO(Output(Bool())) val jtag_tdi = IO(Input(Bool())) val jtag_tdo = IO(Analog(1.W)) val jtag_tck = IO(Input(Clock())) val jtag_tms = IO(Input(Bool())) val uart_rx = IO(Input(Bool())) val uart_tx = IO(Analog(1.W)) // Internal wiring val cpu_clock = Wire(Clock()) val cpu_rst = Wire(Bool()) val jtag_rst = Wire(Bool()) withClockAndReset(cpu_clock, false.B) { val counter = Reg(UInt(64.W)) counter := counter + 1.U cpu_rst := (counter > 1000.U) && (counter < 2000.U) jtag_rst := (counter > 3000.U) && (counter < 4000.U) } cpu_clock <> clk25 } 

इसे तीन फाइलों में क्यों विभाजित किया गया है? खैर, सबसे पहले, यह प्रोटोटाइप में ऐसा था :) Shell को FPGAChip से अलग करने का तर्क, जाहिरा तौर पर, यह था कि शेल बाहरी दुनिया के लिए इंटरफ़ेस का विवरण है: हमारे पास एक विशिष्ट बोर्ड पर क्या निष्कर्ष हैं (और उन्हें कैसे प्रदर्शित किया जाएगा) चिप निष्कर्ष!), और FPGAChip इस तथ्य से निर्धारित होती है कि हम एक विशिष्ट SoC में रटना चाहते हैं। ठीक है, प्लेटफ़ॉर्म को काफी तार्किक रूप से अलग किया जाता है: नोट: ZeowaaShell (और, इसलिए, Platform ) एक RawModule , विशेष रूप से, उनके पास एक निहित clock और reset - यह "वायरिंग बोर्ड" के लिए स्वाभाविक है, लेकिन काम के लिए असुविधाजनक है (और, शायद, विपुल आवृत्ति डोमेन के साथ मुश्किल त्रुटियों से भरा)। खैर, प्लेटफ़ॉर्म पहले से ही एक साधारण छेनी मॉड्यूल है, जिसमें आप रजिस्टर आदि का सुरक्षित रूप से वर्णन कर सकते हैं।

JTAG

JTAG को कॉन्फ़िगर करने के तरीके पर कुछ शब्द। चूंकि मेरे पास पहले से ही रास्पबेरीपी 3 मॉडल बी + था, इसलिए स्पष्ट समाधान किसी तरह से अपने जीपीआईओ का उपयोग करने की कोशिश करना था। सौभाग्य से, हमारे सामने सब कुछ पहले से ही लागू हो गया है : ताजा ओपनओसीडी में interface/sysfsgpio-raspberrypi.cfg का वर्णन है, जिसके साथ आप डिबगर को ब्लॉक (TCK = 11, TMS = 25, TDI = 10, TDO = 9, और 9) से कनेक्ट करने के लिए कह सकते हैं। जीएनडी व्यायाम के रूप में छोड़ दें) - यहां पिनआउट करें ।

इसके अलावा, फ्रीडम.कॉफ को riscv-tests भंडार से एक आधार के रूप में लेते हुए , मुझे निम्नलिखित मिला:

 adapter_khz 10000 source [find interface/sysfsgpio-raspberrypi.cfg] set _CHIPNAME riscv jtag newtap $_CHIPNAME cpu -irlen 5 -expected-id 0x20e31913 set _TARGETNAME $_CHIPNAME.cpu target create $_TARGETNAME riscv -chain-position $_TARGETNAME -rtos riscv init halt echo "Ready for Remote Connections" 

काम करने के लिए, आपको एआरएम के तहत निर्मित riscv-openocd पोर्ट की आवश्यकता होगी, इसलिए फ्रीबी पास नहीं हुआ SiFive से पूर्व-इकट्ठे संस्करण के बजाय, आपको रिपॉजिटरी को क्लोन करना होगा और इकट्ठा करना होगा:

 ./configure --enable-remote-bitbang --enable-sysfsgpio 

अगर किसी को पता है कि रिमोट बिटबैंग को कैसे चलाना है, तो आपको एआरएम के लिए एक कस्टम पोर्ट बनाने की आवश्यकता नहीं हो सकती है ...

नतीजतन, हम रूट से मालिंका पर लॉन्च करते हैं

 root@ubuntu:~/riscv-openocd# ./src/openocd -s tcl -f ../riscv.tcl Open On-Chip Debugger 0.10.0+dev-00614-g998fed1fe-dirty (2019-06-03-10:27) Licensed under GNU GPL v2 For bug reports, read http://openocd.org/doc/doxygen/bugs.html adapter speed: 10000 kHz SysfsGPIO nums: tck = 11, tms = 25, tdi = 10, tdo = 9 SysfsGPIO nums: swclk = 11, swdio = 25 Info : auto-selecting first available session transport "jtag". To override use 'transport select <transport>'. Info : SysfsGPIO JTAG/SWD bitbang driver Info : JTAG and SWD modes enabled Warn : gpio 11 is already exported Warn : gpio 25 is already exported Info : This adapter doesn't support configurable speed Info : JTAG tap: riscv.cpu tap/device found: 0x20e31913 (mfg: 0x489 (SiFive, Inc.), part: 0x0e31, ver: 0x2) Info : datacount=1 progbufsize=16 Info : Disabling abstract command reads from CSRs. Info : Examined RISC-V core; found 1 harts Info : hart 0: XLEN=32, misa=0x40001105 Info : Listening on port 3333 for gdb connections Ready for Remote Connections Info : Listening on port 6666 for tcl connections Info : Listening on port 4444 for telnet connections 

3333 पोर्ट फॉरवर्डिंग के साथ SSH में लॉग इन करने के बाद, वांछित आईपी को प्रतिस्थापित करना:

 ssh -L 3333:127.0.0.1:3333 ubuntu@192.168.1.104 

होस्ट पर अब आप RDBv32 आर्किटेक्चर के तहत GDB चला सकते हैं:

 $ ../../rocket-tools/bin/riscv32-unknown-elf-gdb -q (gdb) target remote :3333 Remote debugging using :3333 warning: No executable has been specified and target does not support determining executable automatically. Try using the "file" command. 0x00000000 in ?? () 

हम इस तथ्य के कारण गैर-चिपके हुए जेटीएजी के कुछ अंधे डिबगिंग को छोड़ देंगे कि मुख्य रूप से उत्पन्न फ़ाइल में SYNTHESIS मैक्रो का सक्रिय रूप से उपयोग किया जाता है, और स्थिति को राज्य में उल्टा कर देता है "जेटीएजी हुक है, लेकिन रोशनी झपकी नहीं है।"

पहला कोड

जैसा कि हमने bootrom/xip/xip.S में देखा था, bootrom/xip/xip.S के लिए कोड को bootrom/xip/xip.S से लिया जाता है। अब यह इस तरह दिखता है:

 // See LICENSE for license details. // Execute in place // Jump directly to XIP_TARGET_ADDR .section .text.init .option norvc .globl _start _start: csrr a0, mhartid la a1, dtb li t0, XIP_TARGET_ADDR jr t0 .section .rodata dtb: .incbin DEVICE_TREE 

मैं समझता हूं कि ओएस द्वारा पढ़ने के लिए एक डिवाइस ट्री (dtb फ़ाइल की सामग्री) होनी चाहिए, लेकिन रैम के बिना ओएस किस तरह का है। इसलिए, साहसपूर्वक अस्थायी रूप से इसे चमकते प्रकाश बल्बों से बदल दें:

  .section .text.init .option norvc .globl _start _start: li a5, 0x64002000 li a1, 0x0F li a2, 0x01 li a3, 0x30 li a6, 0x10 li a7, 0x20 sw zero, 0x38(a5) // iof_en sw a1, 0x08(a5) // output_en sw a2, 0x00(a5) // value sw a1, 0x14(a5) // drive sw a3, 0x04(a5) // input_en // a0 <- timer // a1 <- 0x0F // a2 <- [state] // a3 <- 0x30 // a4 <- [buttons] // a5 <- [gpio addr] // a6 <- 0x10 // a7 <- 0x20 loop: li a4, 0x1000 add a0, a0, a4 bgtu a0, zero, loop lw a4, 0x00(a5) // value beq a4, a6, plus beq a4, a7, minus j store plus: srai a2, a2, 1 beq a2, zero, pzero j store pzero: li a2, 0x08 j store minus: slli a2, a2, 1 beq a2, a6, mzero j store mzero: li a2, 0x01 store: sw a2, 0x0c(a5) // value j loop 

इस कोड ने पुनरावृत्त रूप से विकसित किया है, इसलिए कृपया मुझे रजिस्टरों की अजीब संख्या के लिए क्षमा करें। इसके अलावा, मैंने RISC-V असेंबलर का ईमानदारी से अध्ययन किया "विधि फ़ाइल के कोड के एक टुकड़े को संकलित करें, अलग करें, देखें।" जब मैंने कुछ साल पहले एक इलेक्ट्रॉनिक्स पुस्तक पढ़ी थी, तो उसने असेंबली भाषा में ATTiny प्रोग्रामिंग के बारे में बात की थी। "यहाँ उबाऊ बातें और दिनचर्या है, शायद," मैंने सोचा, लेकिन अब, जाहिरा तौर पर, एक स्वीडिश स्टोर का प्रभाव दिखाई दिया है : लॉकर प्रोसेसर स्पेयर पार्ट्स से इकट्ठा किया, यहां तक ​​कि कोडांतरक भी देशी और दिलचस्प लगता है। इस कोड को निष्पादित करने के परिणामस्वरूप, एलईडी को बाएं या दाएं "रन" करना चाहिए, जिसके आधार पर बटन दबाया जाता है।

हम शुरू करते हैं ... और कुछ भी नहीं: सभी रोशनी चालू हैं, वे बटन का जवाब नहीं देते हैं। चलो JTAG के माध्यम से कनेक्ट करें: प्रोग्राम काउंटर = 0x00000000 - किसी तरह सब कुछ दुखी है। लेकिन 0x64002000 हमारे पास GPIO रजिस्टर उपलब्ध हैं:

 // See LICENSE for license details. package sifive.blocks.devices.gpio object GPIOCtrlRegs { val value = 0x00 val input_en = 0x04 val output_en = 0x08 val port = 0x0c val pullup_en = 0x10 val drive = 0x14 val rise_ie = 0x18 val rise_ip = 0x1c val fall_ie = 0x20 val fall_ip = 0x24 val high_ie = 0x28 val high_ip = 0x2c val low_ie = 0x30 val low_ip = 0x34 val iof_en = 0x38 val iof_sel = 0x3c val out_xor = 0x40 } 

आइए उन्हें मैन्युअल रूप से स्थानांतरित करने का प्रयास करें:

 (gdb) set variable *0x64002038=0 (gdb) set variable *0x64002008=0xF (gdb) set variable *0x64002000=0x1 (gdb) set variable *0x64002014=0xF (gdb) set variable *0x6400200c=0x1 

तो ... एक एल ई डी बाहर चला गया ... और अगर 0x1 नहीं, लेकिन 0x5 ... यह सही है, अब एल ई डी एक के बाद से जलाया जाता है। यह भी स्पष्ट हो गया कि उन्हें उल्टा होने की आवश्यकता है, लेकिन आपको 0x00 रजिस्टर पर लिखने की आवश्यकता नहीं है - आपको वहां से पढ़ने की आवश्यकता है।

 (gdb) x/x 0x64002000 0x64002000: 0x00000030 //    (gdb) x/x 0x64002000 0x64002000: 0x00000020 //   (gdb) x/x 0x64002000 0x64002000: 0x00000010 //   (gdb) x/x 0x64002000 0x64002000: 0x00000000 

खैर, प्रोसेसर को शुरू किए बिना मेमोरी-मैप किए गए रजिस्टरों को अपडेट किया जाता है, आप हर बार कॉन्ट + Ctrl-C दबा नहीं सकते - एक ट्रिफ़ल, लेकिन अच्छा।

लेकिन हम लूप में कताई क्यों नहीं कर रहे हैं, लेकिन $pc=0x0000000 ?

 (gdb) x/10i 0x10000 0x10000: addi s1,sp,12 0x10002: fsd ft0,-242(ra) 0x10006: srli a4,a4,0x21 0x10008: addi s0,sp,32 0x1000a: slli t1,t1,0x21 0x1000c: lb zero,-1744(a2) 0x10010: nop 0x10012: addi a0,sp,416 0x10014: c.slli zero,0x0 0x10016: 0x9308 

क्या है पोकेमॉन ??? मैंने ऐसे निर्देश नहीं लिखे, उन्होंने मुझे फेंक दिया! आइए करीब से देखें:

 (gdb) x/10x 0x10000 0x10000: 0xb7270064 0x9305f000 0x13061000 0x93060003 0x10010: 0x13080001 0x93080002 0x23ac0702 0x23a4b700 0x10020: 0x23a0c700 0x23aab700 

दूसरी ओर, वहाँ क्या होना चाहिए?

 $ ../../rocket-tools/bin/riscv32-unknown-elf-objdump -d builds/zeowaa-e115/xip.elf builds/zeowaa-e115/xip.elf:   elf32-littleriscv   .text: 00010054 <_start>: 10054: 640027b7 lui a5,0x64002 10058: 00f00593 li a1,15 1005c: 00100613 li a2,1 10060: 03000693 li a3,48 10064: 01000813 li a6,16 10068: 02000893 li a7,32 1006c: 0207ac23 sw zero,56(a5) # 64002038 <__global_pointer$+0x63ff0770> 10070: 00b7a423 sw a1,8(a5) 10074: 00c7a023 sw a2,0(a5) 10078: 00b7aa23 sw a1,20(a5) 1007c: 00d7a223 sw a3,4(a5) ... 

जैसा कि आप देख सकते हैं, क्वार्टस ने ईमानदारी से उन्हीं शब्दों को रखा है जो इनिशियलाइज़ेशन फ़ाइल में थे, लेकिन उनकी एंडियननेस बदल गई। आप इसे हल करने के लिए लंबे समय तक Google कर सकते हैं, लेकिन मैं एक प्रोग्रामर हूं , बैसाखी हमारी है, इसलिए मैं बस फिर से लिखूंगा

 module BootROM( input wire [10:0] address, input wire clock, input wire me, input wire oe, output wire [31:0] q ); wire [31:0] q_r; rom r( .address(address), .clock(clock), .rden(me), .q(q_r) ); assign q[31:24] = q_r[7:0]; assign q[23:16] = q_r[15:8]; assign q[15:8] = q_r[23:16]; assign q[7:0] = q_r[31:24]; endmodule 

तो, हम इकट्ठा करते हैं, हम शुरू करते हैं, यह चमक नहीं करता है। JTAG: $pc - , = 4, , output_en : set variable *0x64002008=0xF , c (continue) — ! , . -, , … , output_en .

:

 Total logic elements 17,370 / 114,480 ( 15 % ) Total registers 8357 Total pins 16 / 281 ( 6 % ) Total virtual pins 0 Total memory bits 264,000 / 3,981,312 ( 7 % ) Embedded Multiplier 9-bit elements 4 / 532 ( < 1 % ) 

Chisel

...