/*
 * Copyright 2008-2010, Ingo Weinhold <ingo_weinhold@gmx.de>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */


#include "generic_vm_physical_page_ops.h"

#include <vm/vm.h>
#include <util/AutoLock.h>
#include <util/ThreadAutoLock.h>


status_t
generic_vm_memset_physical(phys_addr_t address, int value, phys_size_t length)
{
        ThreadCPUPinner _(thread_get_current_thread());

        while (length > 0) {
                phys_addr_t pageOffset = address % B_PAGE_SIZE;
                addr_t virtualAddress;
                void* handle;
                status_t error = vm_get_physical_page_current_cpu(address - pageOffset,
                        &virtualAddress, &handle);
                if (error != B_OK)
                        return error;

                size_t toSet = min_c(length, B_PAGE_SIZE - pageOffset);
                memset((void*)(virtualAddress + pageOffset), value, toSet);

                vm_put_physical_page_current_cpu(virtualAddress, handle);

                length -= toSet;
                address += toSet;
        }

        return B_OK;
}


status_t
generic_vm_memcpy_from_physical(void* _to, phys_addr_t from, size_t length,
        bool user)
{
        uint8* to = (uint8*)_to;
        phys_addr_t pageOffset = from % B_PAGE_SIZE;

        ThreadCPUPinner _(thread_get_current_thread());

        while (length > 0) {
                size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset);

                addr_t virtualAddress;
                void* handle;
                status_t error = vm_get_physical_page_current_cpu(from - pageOffset,
                        &virtualAddress, &handle);
                if (error != B_OK)
                        return error;

                if (user) {
                        error = user_memcpy(to, (void*)(virtualAddress + pageOffset),
                                toCopy);
                } else
                        memcpy(to, (void*)(virtualAddress + pageOffset), toCopy);

                vm_put_physical_page_current_cpu(virtualAddress, handle);

                if (error != B_OK)
                        return error;

                to += toCopy;
                from += toCopy;
                length -= toCopy;
                pageOffset = 0;
        }

        return B_OK;
}


status_t
generic_vm_memcpy_to_physical(phys_addr_t to, const void* _from, size_t length,
        bool user)
{
        const uint8* from = (const uint8*)_from;
        phys_addr_t pageOffset = to % B_PAGE_SIZE;

        ThreadCPUPinner _(thread_get_current_thread());

        while (length > 0) {
                size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset);

                addr_t virtualAddress;
                void* handle;
                status_t error = vm_get_physical_page_current_cpu(to - pageOffset,
                        &virtualAddress, &handle);
                if (error != B_OK)
                        return error;

                if (user) {
                        error = user_memcpy((void*)(virtualAddress + pageOffset), from,
                                toCopy);
                } else
                        memcpy((void*)(virtualAddress + pageOffset), from, toCopy);

                vm_put_physical_page_current_cpu(virtualAddress, handle);

                if (error != B_OK)
                        return error;

                to += toCopy;
                from += toCopy;
                length -= toCopy;
                pageOffset = 0;
        }

        return B_OK;
}


/*!     NOTE: If this function is used, vm_get_physical_page_current_cpu() must not
        be blocking, since we need to call it twice and could thus deadlock.
*/
void
generic_vm_memcpy_physical_page(phys_addr_t to, phys_addr_t from)
{
        ThreadCPUPinner _(thread_get_current_thread());

        // map source page
        addr_t fromVirtual;
        void* fromHandle;
        status_t error = vm_get_physical_page_current_cpu(from, &fromVirtual,
                &fromHandle);
        if (error != B_OK) {
                panic("generic_vm_memcpy_physical_page(): Failed to map source page!");
                return;
        }

        // map destination page
        addr_t toVirtual;
        void* toHandle;
        error = vm_get_physical_page_current_cpu(to, &toVirtual, &toHandle);
        if (error == B_OK) {
                // both pages are mapped -- copy
                memcpy((void*)toVirtual, (const void*)fromVirtual, B_PAGE_SIZE);
                vm_put_physical_page_current_cpu(toVirtual, toHandle);
        } else {
                panic("generic_vm_memcpy_physical_page(): Failed to map destination "
                        "page!");
        }

        vm_put_physical_page_current_cpu(fromVirtual, fromHandle);
}