// SPDX-License-Identifier: GPL-2.0 or MIT

//! Arm Mali Tyr DRM driver.
//!
//! The name "Tyr" is inspired by Norse mythology, reflecting Arm's tradition of
//! naming their GPUs after Nordic mythological figures and places.

use crate::driver::TyrDriver;

mod driver;
mod file;
mod gem;
mod gpu;
mod regs;

kernel::module_platform_driver! {
    type: TyrDriver,
    name: "tyr",
    authors: ["The Tyr driver authors"],
    description: "Arm Mali Tyr DRM driver",
    license: "Dual MIT/GPL",
}

kernel::of_device_table!(
    OF_TABLE,
    MODULE_OF_TABLE,
    <TyrDriver as platform::Driver>::IdInfo,
    [
        (of::DeviceId::new(c_str!("rockchip,rk3588-mali")), ()),
        (of::DeviceId::new(c_str!("arm,mali-valhall-csf")), ())
    ]
);

#[pin_data(PinnedDrop)]
pub(crate) struct TyrData {
    pub(crate) pdev: ARef<platform::Device>,

    #[pin]
    clks: Mutex<Clocks>,

    #[pin]
    regulators: Mutex<Regulators>,

    /// Some information on the GPU.
    ///
    /// This is mainly queried by userspace, i.e.: Mesa.
    pub(crate) gpu_info: GpuInfo,
}

impl platform::Driver for TyrDriver {
    type IdInfo = ();
    const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = Some(&OF_TABLE);

    fn probe(
        pdev: &platform::Device<Core>,
        _info: Option<&Self::IdInfo>,
    ) -> Result<Pin<KBox<Self>>> {
        // 1. 获取时钟
        let core_clk = Clk::get(pdev.as_ref(), Some(c_str!("core")))?;
        let stacks_clk = OptionalClk::get(pdev.as_ref(), Some(c_str!("stacks")))?;
        let coregroup_clk = OptionalClk::get(pdev.as_ref(), Some(c_str!("coregroup")))?;

        // 2. 启用时钟
        core_clk.prepare_enable()?;
        stacks_clk.prepare_enable()?;
        coregroup_clk.prepare_enable()?;

        // 3. 获取并启用电源调节器
        let mali_regulator = Regulator::<regulator::Enabled>::get(pdev.as_ref(), c_str!("mali"))?;
        let sram_regulator = Regulator::<regulator::Enabled>::get(pdev.as_ref(), c_str!("sram"))?;

        // 4. 映射MMIO寄存器
        let request = pdev.io_request_by_index(0).ok_or(ENODEV)?;
        let iomem = Arc::pin_init(request.iomap_sized::<SZ_2M>(), GFP_KERNEL)?;

        // 5. 软复位GPU
        issue_soft_reset(pdev.as_ref(), &iomem)?;

        // 6. L2缓存上电
        gpu::l2_power_on(pdev.as_ref(), &iomem)?;

        // 7. 读取GPU信息
        let gpu_info = GpuInfo::new(pdev.as_ref(), &iomem)?;
        gpu_info.log(pdev);

        // 8. 创建DRM设备
        let data = try_pin_init!(TyrData {
            pdev: platform.clone(),
            clks <- new_mutex!(Clocks { ... }),
            regulators <- new_mutex!(Regulators { ... }),
            gpu_info,
        });

        let tdev: ARef<TyrDevice> = drm::Device::new(pdev.as_ref(), data)?;
        drm::driver::Registration::new_foreign_owned(&tdev, pdev.as_ref(), 0)?;

        // 9. 返回驱动实例
        let driver = KBox::pin_init(try_pin_init!(TyrDriver { device: tdev }), GFP_KERNEL)?;

        dev_info!(pdev.as_ref(), "Tyr initialized correctly.\n");
        Ok(driver)
    }
}

let core_clk = Clk::get(pdev.as_ref(), Some(c_str!("core")))?;
core_clk.prepare_enable()?;
// 当core_clk离开作用域时，自动disable + unprepare

let mali_regulator = Regulator::<regulator::Enabled>::get(pdev.as_ref(), c_str!("mali"))?;

let iomem = Arc::pin_init(request.iomap_sized::<SZ_2M>(), GFP_KERNEL)?;

fn issue_soft_reset(dev: &Device<Bound>, iomem: &Devres<IoMem>) -> Result {
    regs::GPU_CMD.write(dev, iomem, regs::GPU_CMD_SOFT_RESET)?;

    // TODO: We cannot poll, as there is no support in Rust currently, so we
    // sleep. Change this when read_poll_timeout() is implemented in Rust.
    kernel::time::delay::fsleep(time::Delta::from_millis(100));

    if regs::GPU_IRQ_RAWSTAT.read(dev, iomem)? & regs::GPU_IRQ_RAWSTAT_RESET_COMPLETED == 0 {
        dev_err!(dev, "GPU reset failed with errno\n");
        dev_err!(
            dev,
            "GPU_INT_RAWSTAT is {}\n",
            regs::GPU_IRQ_RAWSTAT.read(dev, iomem)?
        );

        return Err(EIO);
    }

    Ok(())
}

/// Struct containing information that can be queried by userspace. This is read from
/// the GPU's registers.
///
/// # Invariants
///
/// - The layout of this struct identical to the C `struct drm_panthor_gpu_info`.
#[repr(C)]
pub(crate) struct GpuInfo {
    pub(crate) gpu_id: u32,
    pub(crate) gpu_rev: u32,
    pub(crate) csf_id: u32,
    pub(crate) l2_features: u32,
    pub(crate) tiler_features: u32,
    pub(crate) mem_features: u32,
    pub(crate) mmu_features: u32,
    pub(crate) thread_features: u32,
    pub(crate) max_threads: u32,
    pub(crate) thread_max_workgroup_size: u32,
    pub(crate) thread_max_barrier_size: u32,
    pub(crate) coherency_features: u32,
    pub(crate) texture_features: [u32; 4],
    pub(crate) as_present: u32,
    pub(crate) pad0: u32,
    pub(crate) shader_present: u64,
    pub(crate) l2_present: u64,
    pub(crate) tiler_present: u64,
    pub(crate) core_features: u32,
    pub(crate) pad: u32,
}

impl GpuInfo {
    pub(crate) fn new(dev: &Device<Bound>, iomem: &Devres<IoMem>) -> Result<Self> {
        let gpu_id = regs::GPU_ID.read(dev, iomem)?;
        let csf_id = regs::GPU_CSF_ID.read(dev, iomem)?;
        let gpu_rev = regs::GPU_REVID.read(dev, iomem)?;
        let core_features = regs::GPU_CORE_FEATURES.read(dev, iomem)?;
        let l2_features = regs::GPU_L2_FEATURES.read(dev, iomem)?;
        let tiler_features = regs::GPU_TILER_FEATURES.read(dev, iomem)?;
        let mem_features = regs::GPU_MEM_FEATURES.read(dev, iomem)?;
        let mmu_features = regs::GPU_MMU_FEATURES.read(dev, iomem)?;
        let thread_features = regs::GPU_THREAD_FEATURES.read(dev, iomem)?;
        let max_threads = regs::GPU_THREAD_MAX_THREADS.read(dev, iomem)?;
        let thread_max_workgroup_size = regs::GPU_THREAD_MAX_WORKGROUP_SIZE.read(dev, iomem)?;
        let thread_max_barrier_size = regs::GPU_THREAD_MAX_BARRIER_SIZE.read(dev, iomem)?;
        let coherency_features = regs::GPU_COHERENCY_FEATURES.read(dev, iomem)?;

        let texture_features = regs::GPU_TEXTURE_FEATURES0.read(dev, iomem)?;

        let as_present = regs::GPU_AS_PRESENT.read(dev, iomem)?;

        // 64位寄存器，分两次读取
        let shader_present = u64::from(regs::GPU_SHADER_PRESENT_LO.read(dev, iomem)?);
        let shader_present =
            shader_present | u64::from(regs::GPU_SHADER_PRESENT_HI.read(dev, iomem)?) << 32;

        let tiler_present = u64::from(regs::GPU_TILER_PRESENT_LO.read(dev, iomem)?);
        let tiler_present =
            tiler_present | u64::from(regs::GPU_TILER_PRESENT_HI.read(dev, iomem)?) << 32;

        let l2_present = u64::from(regs::GPU_L2_PRESENT_LO.read(dev, iomem)?);
        let l2_present = l2_present | u64::from(regs::GPU_L2_PRESENT_HI.read(dev, iomem)?) << 32;

        Ok(Self {
            gpu_id,
            gpu_rev,
            csf_id,
            l2_features,
            tiler_features,
            mem_features,
            mmu_features,
            thread_features,
            max_threads,
            thread_max_workgroup_size,
            thread_max_barrier_size,
            coherency_features,
            // TODO: Add texture_features_{1,2,3}.
            texture_features: [texture_features, 0, 0, 0],
            as_present,
            pad0: 0,
            shader_present,
            l2_present,
            tiler_present,
            core_features,
            pad: 0,
        })
    }
}

/// GEM object functions, which must be implemented by drivers.
pub trait BaseDriverObject<T: BaseObject>: Sync + Send + Sized {
    /// Create a new driver data object for a GEM object of a given size.
    fn new(dev: &drm::Device<T::Driver>, size: usize) -> impl PinInit<Self, Error>;

    /// Open a new handle to an existing object, associated with a File.
    fn open(
        _obj: &<<T as IntoGEMObject>::Driver as drm::Driver>::Object,
        _file: &drm::File<<<T as IntoGEMObject>::Driver as drm::Driver>::File>,
    ) -> Result {
        Ok(())
    }

    /// Close a handle to an existing object, associated with a File.
    fn close(
        _obj: &<<T as IntoGEMObject>::Driver as drm::Driver>::Object,
        _file: &drm::File<<<T as IntoGEMObject>::Driver as drm::Driver>::File>,
    ) {
    }
}

// SAFETY: All gem objects are refcounted.
unsafe impl<T: IntoGEMObject> AlwaysRefCounted for T {
    fn inc_ref(&self) {
        // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
        unsafe { bindings::drm_gem_object_get(self.as_raw()) };
    }

    unsafe fn dec_ref(obj: NonNull<Self>) {
        // SAFETY: We either hold the only refcount on `obj`, or one of many - meaning that no one
        // else could possibly hold a mutable reference to `obj` and thus this immutable reference
        // is safe.
        let obj = unsafe { obj.as_ref() }.as_raw();

        // SAFETY:
        // - The safety requirements guarantee that the refcount is non-zero.
        // - We hold no references to `obj` now, making it safe for us to potentially deallocate it.
        unsafe { bindings::drm_gem_object_put(obj) };
    }
}

extern "C" fn open_callback<T: BaseDriverObject<U>, U: BaseObject>(
    raw_obj: *mut bindings::drm_gem_object,
    raw_file: *mut bindings::drm_file,
) -> core::ffi::c_int {
    // SAFETY: `open_callback` is only ever called with a valid pointer to a `struct drm_file`.
    let file = unsafe {
        drm::File::<<<U as IntoGEMObject>::Driver as drm::Driver>::File>::as_ref(raw_file)
    };
    // SAFETY: `open_callback` is specified in the AllocOps structure for `Object<T>`, ensuring that
    // `raw_obj` is indeed contained within a `Object<T>`.
    let obj = unsafe {
        <<<U as IntoGEMObject>::Driver as drm::Driver>::Object as IntoGEMObject>::as_ref(raw_obj)
    };

    match T::open(obj, file) {
        Err(e) => e.to_errno(),
        Ok(()) => 0,
    }
}

#[vtable]
impl drm::Driver for NovaDriver {
    type Data = NovaData;
    type File = File;
    type Object = gem::Object<NovaObject>;

    const INFO: drm::DriverInfo = INFO;

    kernel::declare_drm_ioctls! {
        (NOVA_GETPARAM, drm_nova_getparam, ioctl::RENDER_ALLOW, File::get_param),
        (NOVA_GEM_CREATE, drm_nova_gem_create, ioctl::AUTH | ioctl::RENDER_ALLOW, File::gem_create),
        (NOVA_GEM_INFO, drm_nova_gem_info, ioctl::AUTH | ioctl::RENDER_ALLOW, File::gem_info),
    }
}

// 宏展开后（简化版）
const IOCTLS: &'static [drm::ioctl::DrmIoctlDescriptor] = &[
    drm::ioctl::DrmIoctlDescriptor {
        cmd: drm::ioctl::IOWR::<drm_nova_getparam>(DRM_COMMAND_BASE + 0),
        flags: ioctl::RENDER_ALLOW,
        func: nova_get_param_wrapper,  // 自动生成的C包装器
    },
    // ...
];

// 理想的GPUVM Rust API（概念性）
pub struct GpuVm<T: drm::Driver> {
    inner: Opaque<bindings::drm_gpuvm>,
    _phantom: PhantomData<T>,
}

impl<T: drm::Driver> GpuVm<T> {
    /// 映射GEM对象到GPU虚拟地址
    pub fn map(
        &self,
        gem_obj: &gem::Object<...>,
        va: u64,
        size: usize,
    ) -> Result<GpuVa> {
        // 调用C的drm_gpuva_insert()
    }

    /// 取消映射
    pub fn unmap(&self, va: &GpuVa) -> Result {
        // 调用C的drm_gpuva_remove()
    }
}

pub struct Regulator<S: State> {
    inner: *mut bindings::regulator,
    _state: PhantomData<S>,
}

pub struct Enabled;
pub struct Disabled;

impl Regulator<Disabled> {
    pub fn enable(self) -> Result<Regulator<Enabled>> {
        // unsafe调用C API
        // 转换到Enabled状态
    }
}

impl Regulator<Enabled> {
    pub fn set_voltage(&self, min_uV: i32, max_uV: i32) -> Result {
        // 只有Enabled状态才能设置电压
    }

    pub fn disable(self) -> Result<Regulator<Disabled>> {
        // 转换回Disabled状态
    }
}

// 编译错误：Disabled状态没有set_voltage方法
let reg = Regulator::<Disabled>::get(...)?;
reg.set_voltage(1000000, 1000000)?;  // ❌ 编译失败！

// 正确用法
let reg = reg.enable()?;  // 转换到Enabled
reg.set_voltage(1000000, 1000000)?;  // ✅ 编译通过

{
    let clk = Clk::get(dev, Some(c_str!("core")))?;
    clk.prepare_enable()?;

    do_work()?;  // 即使这里失败提前返回

    // clk离开作用域，自动调用Drop
} // <- 这里自动disable+unprepare

impl Drop for Clk {
    fn drop(&mut self) {
        unsafe {
            bindings::clk_disable_unprepare(self.inner);
        }
    }
}

fn initialize() -> Result {
    let clk = Clk::get(dev, Some(c_str!("core")))?;  // 失败则返回
    let reg = Regulator::get(dev, c_str!("mali"))?;  // 失败则返回
    let iomem = iomap()?;  // 失败则返回

    // 全部成功才继续
    Ok(())
}

// drivers/gpu/drm/tyr/driver.rs - probe函数
// 没有任何unsafe！
fn probe(pdev: &platform::Device<Core>, ...) -> Result<Pin<KBox<Self>>> {
    let core_clk = Clk::get(pdev.as_ref(), Some(c_str!("core")))?;
    core_clk.prepare_enable()?;
    // ... 全部安全代码
}

// rust/kernel/drm/gem/mod.rs
unsafe impl<T: IntoGEMObject> AlwaysRefCounted for T {
    fn inc_ref(&self) {
        unsafe { bindings::drm_gem_object_get(self.as_raw()) };
        // ^^^ unsafe在这里，驱动无需接触
    }
}