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, 67 device::{ 68 self, 69 property::{ 70 FwNodeReferenceArgs, 71 NArgs, // 72 }, 73 Core, 74 }, 75 of, 76 platform, 77 prelude::*, 78 str::CString, 79 sync::aref::ARef, // 80 }; 81 82 struct SampleDriver { 83 pdev: ARef<platform::Device>, 84 } 85 86 struct Info(u32); 87 88 kernel::of_device_table!( 89 OF_TABLE, 90 MODULE_OF_TABLE, 91 <SampleDriver as platform::Driver>::IdInfo, 92 [(of::DeviceId::new(c"test,rust-device"), Info(42))] 93 ); 94 95 kernel::acpi_device_table!( 96 ACPI_TABLE, 97 MODULE_ACPI_TABLE, 98 <SampleDriver as platform::Driver>::IdInfo, 99 [(acpi::DeviceId::new(c"LNUXBEEF"), Info(0))] 100 ); 101 102 impl platform::Driver for SampleDriver { 103 type IdInfo = Info; 104 type Data<'bound> = Self; 105 const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = Some(&OF_TABLE); 106 const ACPI_ID_TABLE: Option<acpi::IdTable<Self::IdInfo>> = Some(&ACPI_TABLE); 107 108 fn probe<'bound>( 109 pdev: &'bound platform::Device<Core<'_>>, 110 info: Option<&'bound Self::IdInfo>, 111 ) -> impl PinInit<Self, Error> + 'bound { 112 let dev = pdev.as_ref(); 113 114 dev_dbg!(dev, "Probe Rust Platform driver sample.\n"); 115 116 if let Some(info) = info { 117 dev_info!(dev, "Probed with info: '{}'.\n", info.0); 118 } 119 120 if dev.fwnode().is_some_and(|node| node.is_of_node()) { 121 Self::properties_parse(dev)?; 122 } 123 124 Ok(Self { pdev: pdev.into() }) 125 } 126 } 127 128 impl SampleDriver { 129 fn properties_parse(dev: &device::Device) -> Result { 130 let fwnode = dev.fwnode().ok_or(ENOENT)?; 131 132 if let Ok(idx) = fwnode.property_match_string(c"compatible", c"test,rust-device") { 133 dev_info!(dev, "matched compatible string idx = {}\n", idx); 134 } 135 136 let name = c"compatible"; 137 let prop = fwnode.property_read::<CString>(name).required_by(dev)?; 138 dev_info!(dev, "'{name}'='{prop:?}'\n"); 139 140 let name = c"test,bool-prop"; 141 let prop = fwnode.property_read_bool(c"test,bool-prop"); 142 dev_info!(dev, "'{name}'='{prop}'\n"); 143 144 if fwnode.property_present(c"test,u32-prop") { 145 dev_info!(dev, "'test,u32-prop' is present\n"); 146 } 147 148 let name = c"test,u32-optional-prop"; 149 let prop = fwnode.property_read::<u32>(name).or(0x12); 150 dev_info!(dev, "'{name}'='{prop:#x}' (default = 0x12)\n"); 151 152 // A missing required property will print an error. Discard the error to 153 // prevent properties_parse from failing in that case. 154 let name = c"test,u32-required-prop"; 155 let _ = fwnode.property_read::<u32>(name).required_by(dev); 156 157 let name = c"test,u32-prop"; 158 let prop: u32 = fwnode.property_read(name).required_by(dev)?; 159 dev_info!(dev, "'{name}'='{prop:#x}'\n"); 160 161 let name = c"test,i16-array"; 162 let prop: [i16; 4] = fwnode.property_read(name).required_by(dev)?; 163 dev_info!(dev, "'{name}'='{prop:?}'\n"); 164 let len = fwnode.property_count_elem::<u16>(name)?; 165 dev_info!(dev, "'{name}' length is {len}\n"); 166 167 let name = c"test,i16-array"; 168 let prop: KVec<i16> = fwnode.property_read_array_vec(name, 4)?.required_by(dev)?; 169 dev_info!(dev, "'{name}'='{prop:?}' (KVec)\n"); 170 171 for child in fwnode.children() { 172 let name = c"test,ref-arg"; 173 let nargs = NArgs::N(2); 174 let prop: FwNodeReferenceArgs = child.property_get_reference_args(name, nargs, 0)?; 175 dev_info!(dev, "'{name}'='{prop:?}'\n"); 176 } 177 178 Ok(()) 179 } 180 } 181 182 impl Drop for SampleDriver { 183 fn drop(&mut self) { 184 dev_dbg!(self.pdev, "Remove Rust Platform driver sample.\n"); 185 } 186 } 187 188 kernel::module_platform_driver! { 189 type: SampleDriver, 190 name: "rust_driver_platform", 191 authors: ["Danilo Krummrich"], 192 description: "Rust Platform driver", 193 license: "GPL v2", 194 } 195