// Copyright 2018 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use sys_util::pagesize;
use crate::address_allocator::AddressAllocator;
use crate::gpu_allocator::{self, GpuMemoryAllocator};
use crate::{Alloc, Error, Result};
/// Manages allocating system resources such as address space and interrupt numbers.
///
/// # Example - Use the `SystemAddress` builder.
///
/// ```
/// # use resources::{Alloc, MmioType, SystemAllocator};
/// if let Ok(mut a) = SystemAllocator::builder()
/// .add_io_addresses(0x1000, 0x10000)
/// .add_high_mmio_addresses(0x10000000, 0x10000000)
/// .add_low_mmio_addresses(0x30000000, 0x10000)
/// .create_allocator(5, false) {
/// assert_eq!(a.allocate_irq(), Some(5));
/// assert_eq!(a.allocate_irq(), Some(6));
/// assert_eq!(
/// a.mmio_allocator(MmioType::High)
/// .allocate(
/// 0x100,
/// Alloc::PciBar { bus: 0, dev: 0, func: 0, bar: 0 },
/// "bar0".to_string()
/// ),
/// Ok(0x10000000)
/// );
/// assert_eq!(
/// a.mmio_allocator(MmioType::High)
/// .get(&Alloc::PciBar { bus: 0, dev: 0, func: 0, bar: 0 }),
/// Some(&(0x10000000, 0x100, "bar0".to_string()))
/// );
/// }
/// ```
/// MMIO address Type
/// Low: address allocated from low_address_space
/// High: address allocated from high_address_space
pub enum MmioType {
Low,
High,
}
#[derive(Debug)]
pub struct SystemAllocator {
io_address_space: Option<AddressAllocator>,
high_mmio_address_space: AddressAllocator,
low_mmio_address_space: AddressAllocator,
gpu_allocator: Option<Box<dyn GpuMemoryAllocator>>,
next_irq: u32,
next_anon_id: usize,
}
impl SystemAllocator {
/// Creates a new `SystemAllocator` for managing addresses and irq numvers.
/// Can return `None` if `base` + `size` overflows a u64 or if alignment isn't a power
/// of two.
///
/// * `io_base` - The starting address of IO memory.
/// * `io_size` - The size of IO memory.
/// * `high_base` - The starting address of high MMIO space.
/// * `high_size` - The size of high MMIO space.
/// * `low_base` - The starting address of low MMIO space.
/// * `low_size` - The size of low MMIO space.
/// * `create_gpu_allocator` - If true, enable gpu memory allocation.
/// * `first_irq` - The first irq number to give out.
fn new(
io_base: Option<u64>,
io_size: Option<u64>,
high_base: u64,
high_size: u64,
low_base: u64,
low_size: u64,
create_gpu_allocator: bool,
first_irq: u32,
) -> Result<Self> {
let page_size = pagesize() as u64;
Ok(SystemAllocator {
io_address_space: if let (Some(b), Some(s)) = (io_base, io_size) {
Some(AddressAllocator::new(b, s, Some(0x400))?)
} else {
None
},
high_mmio_address_space: AddressAllocator::new(high_base, high_size, Some(page_size))?,
low_mmio_address_space: AddressAllocator::new(low_base, low_size, Some(page_size))?,
gpu_allocator: if create_gpu_allocator {
gpu_allocator::create_gpu_memory_allocator().map_err(Error::CreateGpuAllocator)?
} else {
None
},
next_irq: first_irq,
next_anon_id: 0,
})
}
/// Returns a `SystemAllocatorBuilder` that can create a new `SystemAllocator`.
pub fn builder() -> SystemAllocatorBuilder {
SystemAllocatorBuilder::new()
}
/// Reserves the next available system irq number.
pub fn allocate_irq(&mut self) -> Option<u32> {
if let Some(irq_num) = self.next_irq.checked_add(1) {
self.next_irq = irq_num;
Some(irq_num - 1)
} else {
None
}
}
/// Gets an allocator to be used for IO memory.
pub fn io_allocator(&mut self) -> Option<&mut AddressAllocator> {
self.io_address_space.as_mut()
}
/// Gets an allocator to be used for MMIO allocation.
/// MmioType::Low: low mmio allocator
/// MmioType::High: high mmio allocator
pub fn mmio_allocator(&mut self, mmio_type: MmioType) -> &mut AddressAllocator {
match mmio_type {
MmioType::Low => &mut self.low_mmio_address_space,
MmioType::High => &mut self.high_mmio_address_space,
}
}
/// Gets an allocator to be used for GPU memory.
pub fn gpu_memory_allocator(&self) -> Option<&dyn GpuMemoryAllocator> {
self.gpu_allocator.as_ref().map(|v| v.as_ref())
}
/// Gets a unique anonymous allocation
pub fn get_anon_alloc(&mut self) -> Alloc {
self.next_anon_id += 1;
Alloc::Anon(self.next_anon_id)
}
}
/// Used to build a system address map for use in creating a `SystemAllocator`.
pub struct SystemAllocatorBuilder {
io_base: Option<u64>,
io_size: Option<u64>,
low_mmio_base: Option<u64>,
low_mmio_size: Option<u64>,
high_mmio_base: Option<u64>,
high_mmio_size: Option<u64>,
}
impl SystemAllocatorBuilder {
pub fn new() -> Self {
SystemAllocatorBuilder {
io_base: None,
io_size: None,
low_mmio_base: None,
low_mmio_size: None,
high_mmio_base: None,
high_mmio_size: None,
}
}
pub fn add_io_addresses(mut self, base: u64, size: u64) -> Self {
self.io_base = Some(base);
self.io_size = Some(size);
self
}
pub fn add_low_mmio_addresses(mut self, base: u64, size: u64) -> Self {
self.low_mmio_base = Some(base);
self.low_mmio_size = Some(size);
self
}
pub fn add_high_mmio_addresses(mut self, base: u64, size: u64) -> Self {
self.high_mmio_base = Some(base);
self.high_mmio_size = Some(size);
self
}
pub fn create_allocator(
&self,
first_irq: u32,
gpu_allocation: bool,
) -> Result<SystemAllocator> {
SystemAllocator::new(
self.io_base,
self.io_size,
self.high_mmio_base.ok_or(Error::MissingHighMMIOAddresses)?,
self.high_mmio_size.ok_or(Error::MissingHighMMIOAddresses)?,
self.low_mmio_base.ok_or(Error::MissingLowMMIOAddresses)?,
self.low_mmio_size.ok_or(Error::MissingLowMMIOAddresses)?,
gpu_allocation,
first_irq,
)
}
}