Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
gpu: nova-core: falcon: rename load parameters to reflect DMA dependency
The current `FalconLoadParams` and `FalconLoadTarget` types are fit for
DMA loading, but not so much for PIO loading which will require its own
types. Start by renaming them to something that indicates that they are
indeed DMA-related.
Reviewed-by: Eliot Courtney <ecourtney@nvidia.com>
Acked-by: Danilo Krummrich <dakr@kernel.org>
Link: https://patch.msgid.link/20260306-turing_prep-v11-3-8f0042c5d026@nvidia.com
[acourbot@nvidia.com: fixup order of import items.]
Signed-off-by: Alexandre Courbot <acourbot@nvidia.com>
+46
-45
+10
-9
drivers/gpu/nova-core/falcon.rs
+10
-9
drivers/gpu/nova-core/falcon.rs
···
330
330
const ID: Self;
331
331
}
332
332
333
-
/// Represents a portion of the firmware to be loaded into a particular memory (e.g. IMEM or DMEM).
333
+
/// Represents a portion of the firmware to be loaded into a particular memory (e.g. IMEM or DMEM)
334
+
/// using DMA.
334
335
#[derive(Debug, Clone)]
335
-
pub(crate) struct FalconLoadTarget {
336
+
pub(crate) struct FalconDmaLoadTarget {
336
337
/// Offset from the start of the source object to copy from.
337
338
pub(crate) src_start: u32,
338
339
/// Offset from the start of the destination memory to copy into.
···
353
352
pub(crate) ucode_id: u8,
354
353
}
355
354
356
-
/// Trait for providing load parameters of falcon firmwares.
357
-
pub(crate) trait FalconLoadParams {
355
+
/// Trait implemented by falcon firmwares that can be loaded using DMA.
356
+
pub(crate) trait FalconDmaLoadable {
358
357
/// Returns the firmware data as a slice of bytes.
359
358
fn as_slice(&self) -> &[u8];
360
359
361
360
/// Returns the load parameters for Secure `IMEM`.
362
-
fn imem_sec_load_params(&self) -> FalconLoadTarget;
361
+
fn imem_sec_load_params(&self) -> FalconDmaLoadTarget;
363
362
364
363
/// Returns the load parameters for Non-Secure `IMEM`,
365
364
/// used only on Turing and GA100.
366
-
fn imem_ns_load_params(&self) -> Option<FalconLoadTarget>;
365
+
fn imem_ns_load_params(&self) -> Option<FalconDmaLoadTarget>;
367
366
368
367
/// Returns the load parameters for `DMEM`.
369
-
fn dmem_load_params(&self) -> FalconLoadTarget;
368
+
fn dmem_load_params(&self) -> FalconDmaLoadTarget;
370
369
371
370
/// Returns the parameters to write into the BROM registers.
372
371
fn brom_params(&self) -> FalconBromParams;
···
378
377
/// Trait for a falcon firmware.
379
378
///
380
379
/// A falcon firmware can be loaded on a given engine.
381
-
pub(crate) trait FalconFirmware: FalconLoadParams {
380
+
pub(crate) trait FalconFirmware: FalconDmaLoadable {
382
381
/// Engine on which this firmware is to be loaded.
383
382
type Target: FalconEngine;
384
383
}
···
426
425
bar: &Bar0,
427
426
dma_obj: &DmaObject,
428
427
target_mem: FalconMem,
429
-
load_offsets: FalconLoadTarget,
428
+
load_offsets: FalconDmaLoadTarget,
430
429
) -> Result {
431
430
const DMA_LEN: u32 = num::usize_into_u32::<{ MEM_BLOCK_ALIGNMENT }>();
432
431
+16
-16
drivers/gpu/nova-core/firmware.rs
+16
-16
drivers/gpu/nova-core/firmware.rs
···
16
16
17
17
use crate::{
18
18
falcon::{
19
-
FalconFirmware,
20
-
FalconLoadTarget, //
19
+
FalconDmaLoadTarget,
20
+
FalconFirmware, //
21
21
},
22
22
gpu,
23
23
num::{
···
170
170
((hdr & HDR_SIZE_MASK) >> HDR_SIZE_SHIFT).into_safe_cast()
171
171
}
172
172
173
-
fn imem_sec_load_params(&self) -> FalconLoadTarget;
174
-
fn imem_ns_load_params(&self) -> Option<FalconLoadTarget>;
175
-
fn dmem_load_params(&self) -> FalconLoadTarget;
173
+
fn imem_sec_load_params(&self) -> FalconDmaLoadTarget;
174
+
fn imem_ns_load_params(&self) -> Option<FalconDmaLoadTarget>;
175
+
fn dmem_load_params(&self) -> FalconDmaLoadTarget;
176
176
}
177
177
178
178
impl FalconUCodeDescriptor for FalconUCodeDescV2 {
···
204
204
0
205
205
}
206
206
207
-
fn imem_sec_load_params(&self) -> FalconLoadTarget {
208
-
FalconLoadTarget {
207
+
fn imem_sec_load_params(&self) -> FalconDmaLoadTarget {
208
+
FalconDmaLoadTarget {
209
209
src_start: 0,
210
210
dst_start: self.imem_sec_base,
211
211
len: self.imem_sec_size,
212
212
}
213
213
}
214
214
215
-
fn imem_ns_load_params(&self) -> Option<FalconLoadTarget> {
216
-
Some(FalconLoadTarget {
215
+
fn imem_ns_load_params(&self) -> Option<FalconDmaLoadTarget> {
216
+
Some(FalconDmaLoadTarget {
217
217
src_start: 0,
218
218
dst_start: self.imem_phys_base,
219
219
len: self.imem_load_size.checked_sub(self.imem_sec_size)?,
220
220
})
221
221
}
222
222
223
-
fn dmem_load_params(&self) -> FalconLoadTarget {
224
-
FalconLoadTarget {
223
+
fn dmem_load_params(&self) -> FalconDmaLoadTarget {
224
+
FalconDmaLoadTarget {
225
225
src_start: self.dmem_offset,
226
226
dst_start: self.dmem_phys_base,
227
227
len: self.dmem_load_size,
···
258
258
self.signature_versions
259
259
}
260
260
261
-
fn imem_sec_load_params(&self) -> FalconLoadTarget {
262
-
FalconLoadTarget {
261
+
fn imem_sec_load_params(&self) -> FalconDmaLoadTarget {
262
+
FalconDmaLoadTarget {
263
263
src_start: 0,
264
264
dst_start: self.imem_phys_base,
265
265
len: self.imem_load_size,
266
266
}
267
267
}
268
268
269
-
fn imem_ns_load_params(&self) -> Option<FalconLoadTarget> {
269
+
fn imem_ns_load_params(&self) -> Option<FalconDmaLoadTarget> {
270
270
// Not used on V3 platforms
271
271
None
272
272
}
273
273
274
-
fn dmem_load_params(&self) -> FalconLoadTarget {
275
-
FalconLoadTarget {
274
+
fn dmem_load_params(&self) -> FalconDmaLoadTarget {
275
+
FalconDmaLoadTarget {
276
276
src_start: self.imem_load_size,
277
277
dst_start: self.dmem_phys_base,
278
278
len: self.dmem_load_size,
+13
-13
drivers/gpu/nova-core/firmware/booter.rs
+13
-13
drivers/gpu/nova-core/firmware/booter.rs
···
18
18
sec2::Sec2,
19
19
Falcon,
20
20
FalconBromParams,
21
-
FalconFirmware,
22
-
FalconLoadParams,
23
-
FalconLoadTarget, //
21
+
FalconDmaLoadTarget,
22
+
FalconDmaLoadable,
23
+
FalconFirmware, //
24
24
},
25
25
firmware::{
26
26
BinFirmware,
···
256
256
/// The `Booter` loader firmware, responsible for loading the GSP.
257
257
pub(crate) struct BooterFirmware {
258
258
// Load parameters for Secure `IMEM` falcon memory.
259
-
imem_sec_load_target: FalconLoadTarget,
259
+
imem_sec_load_target: FalconDmaLoadTarget,
260
260
// Load parameters for Non-Secure `IMEM` falcon memory,
261
261
// used only on Turing and GA100
262
-
imem_ns_load_target: Option<FalconLoadTarget>,
262
+
imem_ns_load_target: Option<FalconDmaLoadTarget>,
263
263
// Load parameters for `DMEM` falcon memory.
264
-
dmem_load_target: FalconLoadTarget,
264
+
dmem_load_target: FalconDmaLoadTarget,
265
265
// BROM falcon parameters.
266
266
brom_params: FalconBromParams,
267
267
// Device-mapped firmware image.
···
370
370
let (imem_sec_dst_start, imem_ns_load_target) = if chipset <= Chipset::GA100 {
371
371
(
372
372
app0.offset,
373
-
Some(FalconLoadTarget {
373
+
Some(FalconDmaLoadTarget {
374
374
src_start: 0,
375
375
dst_start: load_hdr.os_code_offset,
376
376
len: load_hdr.os_code_size,
···
381
381
};
382
382
383
383
Ok(Self {
384
-
imem_sec_load_target: FalconLoadTarget {
384
+
imem_sec_load_target: FalconDmaLoadTarget {
385
385
src_start: app0.offset,
386
386
dst_start: imem_sec_dst_start,
387
387
len: app0.len,
388
388
},
389
389
imem_ns_load_target,
390
-
dmem_load_target: FalconLoadTarget {
390
+
dmem_load_target: FalconDmaLoadTarget {
391
391
src_start: load_hdr.os_data_offset,
392
392
dst_start: 0,
393
393
len: load_hdr.os_data_size,
···
398
398
}
399
399
}
400
400
401
-
impl FalconLoadParams for BooterFirmware {
401
+
impl FalconDmaLoadable for BooterFirmware {
402
402
fn as_slice(&self) -> &[u8] {
403
403
self.ucode.0.as_slice()
404
404
}
405
405
406
-
fn imem_sec_load_params(&self) -> FalconLoadTarget {
406
+
fn imem_sec_load_params(&self) -> FalconDmaLoadTarget {
407
407
self.imem_sec_load_target.clone()
408
408
}
409
409
410
-
fn imem_ns_load_params(&self) -> Option<FalconLoadTarget> {
410
+
fn imem_ns_load_params(&self) -> Option<FalconDmaLoadTarget> {
411
411
self.imem_ns_load_target.clone()
412
412
}
413
413
414
-
fn dmem_load_params(&self) -> FalconLoadTarget {
414
+
fn dmem_load_params(&self) -> FalconDmaLoadTarget {
415
415
self.dmem_load_target.clone()
416
416
}
417
417
+7
-7
drivers/gpu/nova-core/firmware/fwsec.rs
+7
-7
drivers/gpu/nova-core/firmware/fwsec.rs
···
30
30
gsp::Gsp,
31
31
Falcon,
32
32
FalconBromParams,
33
-
FalconFirmware,
34
-
FalconLoadParams,
35
-
FalconLoadTarget, //
33
+
FalconDmaLoadTarget,
34
+
FalconDmaLoadable,
35
+
FalconFirmware, //
36
36
},
37
37
firmware::{
38
38
FalconUCodeDesc,
···
180
180
ucode: FirmwareObject<Self, Signed>,
181
181
}
182
182
183
-
impl FalconLoadParams for FwsecFirmware {
183
+
impl FalconDmaLoadable for FwsecFirmware {
184
184
fn as_slice(&self) -> &[u8] {
185
185
self.ucode.0.as_slice()
186
186
}
187
187
188
-
fn imem_sec_load_params(&self) -> FalconLoadTarget {
188
+
fn imem_sec_load_params(&self) -> FalconDmaLoadTarget {
189
189
self.desc.imem_sec_load_params()
190
190
}
191
191
192
-
fn imem_ns_load_params(&self) -> Option<FalconLoadTarget> {
192
+
fn imem_ns_load_params(&self) -> Option<FalconDmaLoadTarget> {
193
193
self.desc.imem_ns_load_params()
194
194
}
195
195
196
-
fn dmem_load_params(&self) -> FalconLoadTarget {
196
+
fn dmem_load_params(&self) -> FalconDmaLoadTarget {
197
197
self.desc.dmem_load_params()
198
198
}
199
199