/*
 * Copyright 2005-2013, Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Jan-Rixt Van Hoye
 *              Salvatore Benedetto <salvatore.benedetto@gmail.com>
 *              Michael Lotz <mmlr@mlotz.ch>
 *              Siarzhuk Zharski <imker@gmx.li>
 */
#ifndef OHCI_H
#define OHCI_H

#include "usb_private.h"
#include "ohci_hardware.h"
#include <lock.h>

struct pci_info;
struct pci_device_module_info;
struct pci_device;
class OHCIRootHub;

typedef struct transfer_data {
        Transfer *                                      transfer;
        ohci_endpoint_descriptor *      endpoint;
        ohci_general_td *                       first_descriptor;
        ohci_general_td *                       data_descriptor;
        ohci_general_td *                       last_descriptor;
        bool                                            incoming;
        bool                                            canceled;
        transfer_data *                         link;
} transfer_data;


class OHCI : public BusManager {
public:
                                                                        OHCI(pci_info *info, pci_device_module_info* pci,
                                                                                pci_device* device, Stack *stack, device_node* node);
                                                                        ~OHCI();

                status_t                                        Start();
virtual status_t                                        SubmitTransfer(Transfer *transfer);
virtual status_t                                        CancelQueuedTransfers(Pipe *pipe,
                                                                                bool force);

virtual status_t                                        NotifyPipeChange(Pipe *pipe,
                                                                                usb_change change);

                // Port operations
                uint8                                           PortCount() { return fPortCount; };
                status_t                                        GetPortStatus(uint8 index,
                                                                                usb_port_status *status);
                status_t                                        SetPortFeature(uint8 index, uint16 feature);
                status_t                                        ClearPortFeature(uint8 index, uint16 feature);

                status_t                                        ResetPort(uint8 index);

virtual const char *                            TypeName() const { return "ohci"; };

private:
                // Interrupt functions
static  int32                                           _InterruptHandler(void *data);
                int32                                           _Interrupt();

                // Transfer functions
                status_t                                        _AddPendingTransfer(Transfer *transfer,
                                                                                ohci_endpoint_descriptor *endpoint,
                                                                                ohci_general_td *firstDescriptor,
                                                                                ohci_general_td *dataDescriptor,
                                                                                ohci_general_td *lastDescriptor,
                                                                                bool directionIn);
                status_t                                        _AddPendingIsochronousTransfer(
                                                                                Transfer *transfer,
                                                                                ohci_endpoint_descriptor *endpoint,
                                                                                ohci_isochronous_td *firstDescriptor,
                                                                                ohci_isochronous_td *lastDescriptor,
                                                                                bool directionIn);

                status_t                                        _UnlinkTransfer(transfer_data *transfer);

static  int32                                           _FinishThread(void *data);
                void                                            _FinishTransfers();
                bool                                            _FinishIsochronousTransfer(
                                                                                transfer_data *transfer,
                                                                                transfer_data **_lastTransfer);

                status_t                                        _SubmitRequest(Transfer *transfer);
                status_t                                        _SubmitTransfer(Transfer *transfer);
                status_t                                        _SubmitIsochronousTransfer(
                                                                                Transfer *transfer);

                void                                            _SwitchEndpointTail(
                                                                                ohci_endpoint_descriptor *endpoint,
                                                                                ohci_general_td *first,
                                                                                ohci_general_td *last);
                void                                            _SwitchIsochronousEndpointTail(
                                                                                ohci_endpoint_descriptor *endpoint,
                                                                                ohci_isochronous_td *first,
                                                                                ohci_isochronous_td *last);

                void                                            _RemoveTransferFromEndpoint(
                                                                                transfer_data *transfer);

                // Endpoint related methods
                ohci_endpoint_descriptor *      _AllocateEndpoint();
                void                                            _FreeEndpoint(
                                                                                ohci_endpoint_descriptor *endpoint);
                status_t                                        _InsertEndpointForPipe(Pipe *pipe);
                status_t                                        _RemoveEndpointForPipe(Pipe *pipe);
                ohci_endpoint_descriptor *      _FindInterruptEndpoint(uint8 interval);

                // Transfer descriptor related methods
                ohci_general_td *                       _CreateGeneralDescriptor(
                                                                                size_t bufferSize);
                void                                            _FreeGeneralDescriptor(
                                                                                ohci_general_td *descriptor);
                status_t                                        _CreateDescriptorChain(
                                                                                ohci_general_td **firstDescriptor,
                                                                                ohci_general_td **lastDescriptor,
                                                                                uint32 direction,
                                                                                size_t bufferSize);
                void                                            _FreeDescriptorChain(
                                                                                ohci_general_td *topDescriptor);

                ohci_isochronous_td *           _CreateIsochronousDescriptor(
                                                                                size_t bufferSize);
                void                                            _FreeIsochronousDescriptor(
                                                                                ohci_isochronous_td *descriptor);
                status_t                                        _CreateIsochronousDescriptorChain(
                                                                                ohci_isochronous_td **firstDescriptor,
                                                                                ohci_isochronous_td **lastDescriptor,
                                                                                Transfer *transfer);
                void                                            _FreeIsochronousDescriptorChain(
                                                                                ohci_isochronous_td *topDescriptor);

                size_t                                          _WriteDescriptorChain(
                                                                                ohci_general_td *topDescriptor,
                                                                                generic_io_vec *vector, size_t vectorCount,
                                                                                bool physical);
                size_t                                          _ReadDescriptorChain(
                                                                                ohci_general_td *topDescriptor,
                                                                                generic_io_vec *vector, size_t vectorCount,
                                                                                bool physical);

                size_t                                          _WriteIsochronousDescriptorChain(
                                                                                ohci_isochronous_td *topDescriptor,
                                                                                generic_io_vec *vector, size_t vectorCount,
                                                                                bool physical);
                void                                            _ReadIsochronousDescriptorChain(
                                                                                ohci_isochronous_td *topDescriptor,
                                                                                generic_io_vec *vector, size_t vectorCount,
                                                                                bool physical);

                size_t                                          _ReadActualLength(
                                                                                ohci_general_td *topDescriptor);

                void                                            _LinkDescriptors(ohci_general_td *first,
                                                                                ohci_general_td *second);
                void                                            _LinkIsochronousDescriptors(
                                                                                ohci_isochronous_td *first,
                                                                                ohci_isochronous_td *second,
                                                                                ohci_isochronous_td *nextDone);

                bool                                            _AllocateIsochronousBandwidth(uint16 frame,
                                                                                uint16 size);
                void                                            _ReleaseIsochronousBandwidth(
                                                                                uint16 startFrame, uint16 count);

                status_t                                        _GetStatusOfConditionCode(
                                                                                uint8 conditionCode);
                // Private locking
                bool                                            _LockEndpoints();
                void                                            _UnlockEndpoints();

                // Register functions
inline  void                                            _WriteReg(uint32 reg, uint32 value);
inline  uint32                                          _ReadReg(uint32 reg);

                // Debug functions
                void                                            _PrintEndpoint(
                                                                                ohci_endpoint_descriptor *endpoint);
                void                                            _PrintDescriptorChain(
                                                                                ohci_general_td *topDescriptor);
                void                                            _PrintDescriptorChain(
                                                                                ohci_isochronous_td *topDescriptor);

                pci_info *                                      fPCIInfo;
                pci_device_module_info*         fPci;
                pci_device*                                     fDevice;
                Stack *                                         fStack;

                uint8 *                                         fOperationalRegisters;
                area_id                                         fRegisterArea;

                // Host Controller Communication Area related stuff
                area_id                                         fHccaArea;
                ohci_hcca *                                     fHcca;
                ohci_endpoint_descriptor **     fInterruptEndpoints;

                // Endpoint management
                mutex                                           fEndpointLock;
                ohci_endpoint_descriptor *      fDummyControl;
                ohci_endpoint_descriptor *      fDummyBulk;
                ohci_endpoint_descriptor *      fDummyIsochronous;

                // Maintain a linked list of transfer
                transfer_data *                         fFirstTransfer;
                transfer_data *                         fLastTransfer;
                sem_id                                          fFinishTransfersSem;
                thread_id                                       fFinishThread;
                bool                                            fStopFinishThread;
                Pipe *                                          fProcessingPipe;
                // frame bandwidth watchdogs array
                uint16 *                                        fFrameBandwidth;

                // Root Hub
                OHCIRootHub *                           fRootHub;
                uint8                                           fRootHubAddress;

                // Port management
                uint8                                           fPortCount;

                uint32                                          fIRQ;
                bool                                            fUseMSI;
};


class OHCIRootHub : public Hub {
public:
                                                                        OHCIRootHub(Object *rootObject,
                                                                                int8 deviceAddress);

static  status_t                                        ProcessTransfer(OHCI *ohci,
                                                                                Transfer *transfer);
};


#endif // OHCI_H