/*
 * Copyright (c) 2002-2004, Thomas Kurschel
 * Distributed under the terms of the MIT license.
 */
#ifndef _RADEON_DRIVER_H
#define _RADEON_DRIVER_H


#include "radeon_interface.h"
#include "memory_manager.h"

#include <KernelExport.h>
#include <GraphicsDefs.h>
#include "AGP.h"

// logging helpers
extern int debug_level_flow;
extern int debug_level_info;
extern int debug_level_error;

/*#define DEBUG_WAIT_ON_MSG 1000000
#define DEBUG_WAIT_ON_ERROR 1000000*/

#define DEBUG_MSG_PREFIX "Radeon - "
#include "debug_ext.h"

#include "log_coll.h"


#define MAX_DEVICES     8

// size of PCI GART;
// the only user is the command processor, which needs 1 MB,
// so make sure that GART is large enough
#define PCI_GART_SIZE 1024*1024

// size of CP ring buffer in dwords
#define CP_RING_SIZE 2048


// GART info (either PCI or AGP)
typedef struct {
        // data accessed via GART
        struct {
                area_id area;                   // area of data
                size_t size;                    // size of buffer
                void *ptr;                              // CPU pointer to data
                area_id unaligned_area; // unaligned address (see PCI_GART.c)
        } buffer;

        // GATT info (address translation table)
        struct {
                area_id area;                   // area containing GATT
                uint32 *ptr;                    // CPU pointer to GATT
                uint32 phys;                    // physical address of GATT
        } GATT;
} GART_info;

// info about graphics RAM
typedef struct {
        int ml;
        int MB;
        int Trcd;
        int Trp;
        int Twr;
        int CL;
        int Tr2w;
        int loop_latency;
        int Rloop;
        int width;
} ram_info;

// ROM information
typedef struct {
        area_id         bios_area;              // only mapped during detection
        
        uint32          phys_address;   // physical address of BIOS
        uint32          size;                   // size in bytes
        
        // the following is only useful if ROM is mapped during detection,
        // but the difference if the offset of hw info
        uint8           *bios_ptr;              // begin of entire BIOS
        uint8           *rom_ptr;               // begin of ROM containing hw info
} rom_info;


// timer for VBI emulation
typedef struct {
        timer           te;                             /* timer entry for add_timer() */
        struct device_info      *di;    /* pointer to the owning device */
        bigtime_t       when_target;    /* when we're supposed to wake up */
} timer_info;


// info about one device
typedef struct device_info {
        uint32          is_open;
        area_id         shared_area;
        shared_info     *si;
        
        area_id         virtual_card_area;
        virtual_card *vc;
        vuint8          *regs;

        radeon_type     asic;
        uint8           num_crtc;
        tv_chip_type tv_chip;
        bool            is_mobility;
        bool            new_pll;
        bool            has_vip;
        bool            is_igp;
        bool            has_no_i2c;
        bool            acc_dma;

        fp_info         fp_info;
        disp_entity     routing;
        
        general_pll_info pll;
        tmds_pll_info    tmds_pll[4];
        ram_info        ram;    
        char            ram_type[32];   // human-readable name of ram type
        uint32          local_mem_size;

        rom_info        rom;
        bool            is_atombios;    // legacy ROM, or "AtomBios"
        
        GART_info       pci_gart;               // PCI GART
        GART_info       agp_gart;               // AGP GART (unsupported)
        memory_type_e   nonlocal_map;   // default type of non-local memory;
        
        mem_info        *memmgr[mt_last+1];     // memory managers;
                                                                // if there is no AGP; the entries for non_local
                                                                // and PCI are the same
        
        // VBI data
        uint32      interrupt_count;
        uint32          vbi_count[2];
        // VBI emulation
        int32           shutdown_virtual_irq;   // true, to shutdown virtual interrupts
        timer_info  ti_a;           /* a pool of two timer managment buffers */
    timer_info  ti_b;
    timer_info  *current_timer; /* the timer buffer that's currently in use */
    
    // DMA GUI engine
    sem_id              dma_sem;
    uint32              dma_desc_max_num;
    uint32              dma_desc_handle;
    uint32              dma_desc_offset;
    
    // capture engine
    spinlock    cap_spinlock;   // synchronization for following capture data
        sem_id          cap_sem;                // semaphore released on capture interrupt
        uint32          cap_int_status; // content of CAP_INT_STATUS during lost capture irq
        uint32          cap_counter;    // counter of capture interrupts
        bigtime_t       cap_timestamp;  // timestamp of last capture interrupt
    
        uint32          dac2_cntl;              // original dac2_cntl register content

        radeon_settings settings;       // overrides read from radeon.settings

        pci_info        pcii;
        agp_info        agpi;
        char            name[MAX_RADEON_DEVICE_NAME_LENGTH];
        char            video_name[MAX_RADEON_DEVICE_NAME_LENGTH];
} device_info;


// device list and some global data
typedef struct {
        uint32          count;
        benaphore       kernel;
        // every device is exported as a graphics and a video card
        char            *device_names[2*MAX_DEVICES+1];
        device_info     di[MAX_DEVICES];
} radeon_devices;


extern pci_module_info *pci_bus;
extern agp_gart_module_info *sAGP;
extern radeon_devices *devices;


// detect.c
bool Radeon_CardDetect( void );
void Radeon_ProbeDevices( void );


// init.c
status_t Radeon_FirstOpen( device_info *di );
void Radeon_LastClose( device_info *di );
status_t Radeon_MapDevice( device_info *di, bool mmio_only );
void Radeon_UnmapDevice(device_info *di);


// bios.c
status_t Radeon_MapBIOS( pci_info *pcii, rom_info *ri );
void Radeon_UnmapBIOS( rom_info *ri );
status_t Radeon_ReadBIOSData( device_info *di );
        

// PCI_GART.c
status_t Radeon_InitPCIGART( device_info *di );
void Radeon_CleanupPCIGART( device_info *di );


// irq.c
status_t Radeon_SetupIRQ( device_info *di, char *buffer );
void Radeon_CleanupIRQ( device_info *di );


// agp.c
void Radeon_Set_AGP( device_info *di, bool enable_agp );


// mem_controller.c
void Radeon_InitMemController( device_info *di );


// CP_setup.c
void Radeon_WaitForIdle( device_info *di, bool acquire_lock, bool keep_lock );
void Radeon_WaitForFifo( device_info *di, int entries );
void Radeon_ResetEngine( device_info *di );
status_t Radeon_InitCP( device_info *di );
void Radeon_UninitCP( device_info *di );
void Radeon_SetDynamicClock( device_info *di, int mode );


// vip.c
bool Radeon_VIPRead( device_info *di, uint channel, uint address, uint32 *data, bool lock );
bool Radeon_VIPWrite( device_info *di, uint8 channel, uint address, uint32 data, bool lock );
bool Radeon_VIPFifoRead(device_info *di, uint8 channel, uint32 address, uint32 count, uint8 *buffer, bool lock);
bool Radeon_VIPFifoWrite(device_info *di, uint8 channel, uint32 address, uint32 count, uint8 *buffer, bool lock);
int Radeon_FindVIPDevice( device_info *di, uint32 device_id );
void Radeon_VIPReset( device_info *di, bool lock );


// dma.c
status_t Radeon_InitDMA( device_info *di );
status_t Radeon_DMACopy( 
        device_info *di, uint32 src, char *target, size_t size, 
        bool lock_mem, bool contiguous );
        
#endif