/*
 * Copyright 2011-2015, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Michael Lotz, mmlr@mlotz.ch
 *              Alexander von Gluck IV, kallisti5@unixzen.com
 */
#ifndef INTEL_PORTS_H
#define INTEL_PORTS_H


#include <dp.h>
#include <edid.h>

#include "intel_extreme.h"

#include "Pipes.h"
#include "pll.h"


#define MAX_PORTS       20      // a generous upper bound

struct pll_limits;
struct i2c_bus;

enum port_type {
        INTEL_PORT_TYPE_ANY,            // wildcard for lookup functions
        INTEL_PORT_TYPE_ANALOG,
        INTEL_PORT_TYPE_DVI,
        INTEL_PORT_TYPE_LVDS,
        INTEL_PORT_TYPE_DP,
        INTEL_PORT_TYPE_eDP,
        INTEL_PORT_TYPE_HDMI
};


class Port {
public:
                                                                        Port(port_index index,
                                                                                const char* baseName);
virtual                                                         ~Port();

virtual uint32                                          Type() const = 0;
                const char*                                     PortName() const
                                                                                { return fPortName; }

                port_index                                      PortIndex() const
                                                                                { return fPortIndex; }

virtual bool                                            IsConnected() = 0;

virtual status_t                                        SetPipe(Pipe* pipe);
                ::Pipe*                                         GetPipe()
                                                                                { return fPipe; };

virtual status_t                                        Power(bool enabled);

                bool                                            HasEDID();
virtual status_t                                        GetEDID(edid1_info* edid,
                                                                                bool forceRead = false);
virtual status_t                                        SetupI2c(struct i2c_bus *bus);
virtual status_t                                        SetupI2cFallback(struct i2c_bus *bus);

virtual status_t                                        GetPLLLimits(pll_limits& limits);

virtual status_t                                        SetDisplayMode(display_mode* mode,
                                                                                uint32 colorMode) { return B_ERROR; };

virtual pipe_index                                      PipePreference();

protected:
                void                                            _SetName(const char* name);

static  status_t                                        _GetI2CSignals(void* cookie, int* _clock,
                                                                                int* _data);
static  status_t                                        _SetI2CSignals(void* cookie, int clock,
                                                                                int data);
                bool                                            _IsPortInVBT(uint32* foundIndex = NULL);
                bool                                            _IsDisplayPortInVBT();
                bool                                            _IsHdmiInVBT();
                bool                                            _IsEDPPort();
                addr_t                                          _DDCPin();
                status_t                                        _SetupDpAuxI2c(struct i2c_bus *bus);

                ssize_t                                         _DpAuxTransfer(dp_aux_msg* message);
                ssize_t                                         _DpAuxTransfer(uint8* transmitBuffer, uint8 transmitSize,
                                                                                uint8* receiveBuffer, uint8 receiveSize);
                status_t                                        _DpAuxSendReceive(uint32 slave_address,
                                                                                const uint8 *writeBuffer, size_t writeLength,
                                                                                uint8 *readBuffer, size_t readLength);
static  status_t                                        _DpAuxSendReceiveHook(const struct i2c_bus *bus,
                                                                                uint32 slave_address, const uint8 *writeBuffer,
                                                                                size_t writeLength, uint8 *readBuffer,
                                                                                size_t readLength);
                aux_channel                                     _DpAuxChannel();

                display_mode                            fCurrentMode;
                Pipe*                                           fPipe;

                status_t                                        fEDIDState;
                edid1_info                                      fEDIDInfo;

private:
virtual addr_t                                          _DDCRegister() = 0;
virtual addr_t                                          _PortRegister() = 0;

                port_index                                      fPortIndex;
                char*                                           fPortName;
};


class AnalogPort : public Port {
public:
                                                                        AnalogPort();

virtual uint32                                          Type() const
                                                                                { return INTEL_PORT_TYPE_ANALOG; }

virtual bool                                            IsConnected();

virtual status_t                                        SetDisplayMode(display_mode* mode,
                                                                                uint32 colorMode);

protected:
virtual addr_t                                          _DDCRegister();
virtual addr_t                                          _PortRegister();
};


class LVDSPort : public Port {
public:
                                                                        LVDSPort();

virtual uint32                                          Type() const
                                                                                { return INTEL_PORT_TYPE_LVDS; }

virtual bool                                            IsConnected();

virtual status_t                                        SetDisplayMode(display_mode* mode,
                                                                                uint32 colorMode);

virtual pipe_index                                      PipePreference();

protected:
virtual addr_t                                          _DDCRegister();
virtual addr_t                                          _PortRegister();
};


class DigitalPort : public Port {
public:
                                                                        DigitalPort(
                                                                                port_index index = INTEL_PORT_B,
                                                                                const char* baseName = "DVI");

virtual uint32                                          Type() const
                                                                                { return INTEL_PORT_TYPE_DVI; }

virtual bool                                            IsConnected();

virtual status_t                                        SetDisplayMode(display_mode* mode,
                                                                                uint32 colorMode);

protected:
virtual addr_t                                          _DDCRegister();
virtual addr_t                                          _PortRegister();
};


class HDMIPort : public DigitalPort {
public:
                                                                        HDMIPort(port_index index);

virtual uint32                                          Type() const
                                                                                { return INTEL_PORT_TYPE_HDMI; }

virtual bool                                            IsConnected();

protected:
virtual addr_t                                          _PortRegister();
};


class DisplayPort : public Port {
public:
                                                                        DisplayPort(port_index index,
                                                                                const char* baseName = "DisplayPort");

virtual uint32                                          Type() const
                                                                                { return INTEL_PORT_TYPE_DP; }

virtual status_t                                        SetPipe(Pipe* pipe);
virtual status_t                                        SetupI2c(i2c_bus *bus);

virtual bool                                            IsConnected();

virtual status_t                                        SetDisplayMode(display_mode* mode,
                                                                                uint32 colorMode);

virtual pipe_index                                      PipePreference();

protected:
virtual addr_t                                          _DDCRegister();
virtual addr_t                                          _PortRegister();

private:
                status_t                                        _SetPortLinkGen4(const display_timing& timing);
                status_t                                        _SetPortLinkGen6(const display_timing& timing);
};


class EmbeddedDisplayPort : public DisplayPort {
public:
                                                                        EmbeddedDisplayPort();

virtual uint32                                          Type() const
                                                                                { return INTEL_PORT_TYPE_eDP; }

virtual bool                                            IsConnected();
};


class DigitalDisplayInterface : public Port {
public:
                                                                        DigitalDisplayInterface(
                                                                                port_index index = INTEL_PORT_A,
                                                                                const char* baseName = "Digital Display Interface");

virtual uint32                                          Type() const
                                                                                { return INTEL_PORT_TYPE_DVI; }

virtual status_t                                        Power(bool enabled);

virtual status_t                                        SetPipe(Pipe* pipe);
virtual status_t                                        SetupI2c(i2c_bus *bus);
virtual status_t                                        SetupI2cFallback(struct i2c_bus *bus);

virtual bool                                            IsConnected();

virtual status_t                                        SetDisplayMode(display_mode* mode,
                                                                                uint32 colorMode);

protected:
virtual addr_t                                          _DDCRegister();
virtual addr_t                                          _PortRegister();
private:
                uint8                                           fMaxLanes;

                status_t                                        _SetPortLinkGen8(const display_timing& timing,
                                                                                uint32 pllSel);
};


#endif // INTEL_PORTS_H