1 // SPDX-License-Identifier: GPL-2.0 2 3 //! Rust Platform driver sample. 4 5 //! ACPI match table test 6 //! 7 //! This demonstrates how to test an ACPI-based Rust platform driver using QEMU 8 //! with a custom SSDT. 9 //! 10 //! Steps: 11 //! 12 //! 1. **Create an SSDT source file** (`ssdt.dsl`) with the following content: 13 //! 14 //! ```asl 15 //! DefinitionBlock ("", "SSDT", 2, "TEST", "VIRTACPI", 0x00000001) 16 //! { 17 //! Scope (\_SB) 18 //! { 19 //! Device (T432) 20 //! { 21 //! Name (_HID, "LNUXBEEF") // ACPI hardware ID to match 22 //! Name (_UID, 1) 23 //! Name (_STA, 0x0F) // Device present, enabled 24 //! Name (_CRS, ResourceTemplate () 25 //! { 26 //! Memory32Fixed (ReadWrite, 0xFED00000, 0x1000) 27 //! }) 28 //! } 29 //! } 30 //! } 31 //! ``` 32 //! 33 //! 2. **Compile the table**: 34 //! 35 //! ```sh 36 //! iasl -tc ssdt.dsl 37 //! ``` 38 //! 39 //! This generates `ssdt.aml` 40 //! 41 //! 3. **Run QEMU** with the compiled AML file: 42 //! 43 //! ```sh 44 //! qemu-system-x86_64 -m 512M \ 45 //! -enable-kvm \ 46 //! -kernel path/to/bzImage \ 47 //! -append "root=/dev/sda console=ttyS0" \ 48 //! -hda rootfs.img \ 49 //! -serial stdio \ 50 //! -acpitable file=ssdt.aml 51 //! ``` 52 //! 53 //! Requirements: 54 //! - The `rust_driver_platform` must be present either: 55 //! - built directly into the kernel (`bzImage`), or 56 //! - available as a `.ko` file and loadable from `rootfs.img` 57 //! 58 //! 4. **Verify it worked** by checking `dmesg`: 59 //! 60 //! ``` 61 //! rust_driver_platform LNUXBEEF:00: Probed with info: '0'. 62 //! ``` 63 //! 64 65 use kernel::{ 66 acpi, c_str, 67 device::{ 68 self, 69 property::{FwNodeReferenceArgs, NArgs}, 70 Core, 71 }, 72 of, platform, 73 prelude::*, 74 str::CString, 75 types::ARef, 76 }; 77 78 struct SampleDriver { 79 pdev: ARef<platform::Device>, 80 } 81 82 struct Info(u32); 83 84 kernel::of_device_table!( 85 OF_TABLE, 86 MODULE_OF_TABLE, 87 <SampleDriver as platform::Driver>::IdInfo, 88 [(of::DeviceId::new(c_str!("test,rust-device")), Info(42))] 89 ); 90 91 kernel::acpi_device_table!( 92 ACPI_TABLE, 93 MODULE_ACPI_TABLE, 94 <SampleDriver as platform::Driver>::IdInfo, 95 [(acpi::DeviceId::new(c_str!("LNUXBEEF")), Info(0))] 96 ); 97 98 impl platform::Driver for SampleDriver { 99 type IdInfo = Info; 100 const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = Some(&OF_TABLE); 101 const ACPI_ID_TABLE: Option<acpi::IdTable<Self::IdInfo>> = Some(&ACPI_TABLE); 102 probe( pdev: &platform::Device<Core>, info: Option<&Self::IdInfo>, ) -> Result<Pin<KBox<Self>>>103 fn probe( 104 pdev: &platform::Device<Core>, 105 info: Option<&Self::IdInfo>, 106 ) -> Result<Pin<KBox<Self>>> { 107 let dev = pdev.as_ref(); 108 109 dev_dbg!(dev, "Probe Rust Platform driver sample.\n"); 110 111 if let Some(info) = info { 112 dev_info!(dev, "Probed with info: '{}'.\n", info.0); 113 } 114 115 if dev.fwnode().is_some_and(|node| node.is_of_node()) { 116 Self::properties_parse(dev)?; 117 } 118 119 let drvdata = KBox::new(Self { pdev: pdev.into() }, GFP_KERNEL)?; 120 121 Ok(drvdata.into()) 122 } 123 } 124 125 impl SampleDriver { properties_parse(dev: &device::Device) -> Result126 fn properties_parse(dev: &device::Device) -> Result { 127 let fwnode = dev.fwnode().ok_or(ENOENT)?; 128 129 if let Ok(idx) = 130 fwnode.property_match_string(c_str!("compatible"), c_str!("test,rust-device")) 131 { 132 dev_info!(dev, "matched compatible string idx = {}\n", idx); 133 } 134 135 let name = c_str!("compatible"); 136 let prop = fwnode.property_read::<CString>(name).required_by(dev)?; 137 dev_info!(dev, "'{name}'='{prop:?}'\n"); 138 139 let name = c_str!("test,bool-prop"); 140 let prop = fwnode.property_read_bool(c_str!("test,bool-prop")); 141 dev_info!(dev, "'{name}'='{prop}'\n"); 142 143 if fwnode.property_present(c_str!("test,u32-prop")) { 144 dev_info!(dev, "'test,u32-prop' is present\n"); 145 } 146 147 let name = c_str!("test,u32-optional-prop"); 148 let prop = fwnode.property_read::<u32>(name).or(0x12); 149 dev_info!(dev, "'{name}'='{prop:#x}' (default = 0x12)\n",); 150 151 // A missing required property will print an error. Discard the error to 152 // prevent properties_parse from failing in that case. 153 let name = c_str!("test,u32-required-prop"); 154 let _ = fwnode.property_read::<u32>(name).required_by(dev); 155 156 let name = c_str!("test,u32-prop"); 157 let prop: u32 = fwnode.property_read(name).required_by(dev)?; 158 dev_info!(dev, "'{name}'='{prop:#x}'\n"); 159 160 let name = c_str!("test,i16-array"); 161 let prop: [i16; 4] = fwnode.property_read(name).required_by(dev)?; 162 dev_info!(dev, "'{name}'='{prop:?}'\n"); 163 let len = fwnode.property_count_elem::<u16>(name)?; 164 dev_info!(dev, "'{name}' length is {len}\n",); 165 166 let name = c_str!("test,i16-array"); 167 let prop: KVec<i16> = fwnode.property_read_array_vec(name, 4)?.required_by(dev)?; 168 dev_info!(dev, "'{name}'='{prop:?}' (KVec)\n"); 169 170 for child in fwnode.children() { 171 let name = c_str!("test,ref-arg"); 172 let nargs = NArgs::N(2); 173 let prop: FwNodeReferenceArgs = child.property_get_reference_args(name, nargs, 0)?; 174 dev_info!(dev, "'{name}'='{prop:?}'\n"); 175 } 176 177 Ok(()) 178 } 179 } 180 181 impl Drop for SampleDriver { drop(&mut self)182 fn drop(&mut self) { 183 dev_dbg!(self.pdev.as_ref(), "Remove Rust Platform driver sample.\n"); 184 } 185 } 186 187 kernel::module_platform_driver! { 188 type: SampleDriver, 189 name: "rust_driver_platform", 190 authors: ["Danilo Krummrich"], 191 description: "Rust Platform driver", 192 license: "GPL v2", 193 } 194