/*
 * Copyright 2008-2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2008, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef DMA_RESOURCES_H
#define DMA_RESOURCES_H


#include <sys/uio.h>

#include <fs_interface.h>

#include <lock.h>
#include <util/DoublyLinkedList.h>
#include <util/iovec_support.h>


struct device_node;
struct IOOperation;
struct IORequest;


struct dma_restrictions {
        generic_addr_t  low_address;
        generic_addr_t  high_address;
        generic_size_t  alignment;
        generic_size_t  boundary;
        generic_size_t  max_transfer_size;
        uint32                  max_segment_count;
        generic_size_t  max_segment_size;
        uint32                  flags;
};


struct DMABounceBuffer : public DoublyLinkedListLinkImpl<DMABounceBuffer> {
        void*           address;
        phys_addr_t     physical_address;
        phys_size_t     size;
};

typedef DoublyLinkedList<DMABounceBuffer> DMABounceBufferList;


class DMABuffer : public DoublyLinkedListLinkImpl<DMABuffer> {
public:
        static  DMABuffer*                      Create(size_t count);

                        generic_io_vec*         Vecs() { return fVecs; }
                        generic_io_vec&         VecAt(size_t index) { return fVecs[index]; }
                        uint32                          VecCount() const { return fVecCount; }
                        void                            SetVecCount(uint32 count);

                        void                            AddVec(generic_addr_t base,
                                                                        generic_size_t size);

                        void                            SetBounceBuffer(DMABounceBuffer* bounceBuffer)
                                                                        { fBounceBuffer = bounceBuffer; }
                        DMABounceBuffer*        BounceBuffer() const { return fBounceBuffer; }

                        void*                           BounceBufferAddress() const
                                                                        { return fBounceBuffer
                                                                                ? fBounceBuffer->address : NULL; }
                        phys_addr_t                     PhysicalBounceBufferAddress() const
                                                                        { return fBounceBuffer
                                                                                ? fBounceBuffer->physical_address
                                                                                : 0; }
                        phys_size_t                     BounceBufferSize() const
                                                                        { return fBounceBuffer
                                                                                ? fBounceBuffer->size : 0; }

                        bool                            UsesBounceBufferAt(uint32 index);

                        void                            Dump() const;

private:
                        DMABounceBuffer*        fBounceBuffer;
                        uint32                          fVecCount;
                        generic_io_vec          fVecs[1];
};


typedef DoublyLinkedList<DMABuffer> DMABufferList;


class DMAResource {
public:
                                                                DMAResource();
                                                                ~DMAResource();

                        status_t                        Init(const dma_restrictions& restrictions,
                                                                        generic_size_t blockSize,
                                                                        uint32 bufferCount,
                                                                        uint32 bounceBufferCount);
                        status_t                        Init(device_node* node,
                                                                        generic_size_t blockSize,
                                                                        uint32 bufferCount,
                                                                        uint32 bounceBufferCount);

                        status_t                        CreateBuffer(DMABuffer** _buffer);
                        status_t                        CreateBounceBuffer(DMABounceBuffer** _buffer);

                        status_t                        TranslateNext(IORequest* request,
                                                                        IOOperation* operation,
                                                                        generic_size_t maxOperationLength);
                        void                            RecycleBuffer(DMABuffer* buffer);

                        generic_size_t          BlockSize() const       { return fBlockSize; }
                        uint32                          BufferCount() const { return fBufferCount; }

private:
                        bool                            _NeedsBoundsBuffers() const;
                        void                            _RestrictBoundaryAndSegmentSize(
                                                                        generic_addr_t base,
                                                                        generic_addr_t& length);
                        void                            _CutBuffer(DMABuffer& buffer,
                                                                        phys_addr_t& physicalBounceBuffer,
                                                                        phys_size_t& bounceLeft,
                                                                        generic_size_t toCut);
                        phys_size_t                     _AddBounceBuffer(DMABuffer& buffer,
                                                                        phys_addr_t& physicalBounceBuffer,
                                                                        phys_size_t& bounceLeft,
                                                                        generic_size_t length, bool fixedLength);

                        mutex                           fLock;
                        dma_restrictions        fRestrictions;
                        generic_size_t          fBlockSize;
                        uint32                          fBufferCount;
                        uint32                          fBounceBufferCount;
                        phys_size_t                     fBounceBufferSize;
                        DMABufferList           fDMABuffers;
                        DMABounceBufferList     fBounceBuffers;
                        generic_io_vec*         fScratchVecs;
};

#endif  // DMA_RESOURCES_H