UsbHub.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef USBHUB_H
#define USBHUB_H

#include "modules/system/usb/Usb.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/Device.h"
#include "pedigree/kernel/process/Semaphore.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/ExtensibleBitmap.h"

class EXPORTED_PUBLIC UsbHub : public Device
{
  public:
    UsbHub();
    UsbHub(Device *p);

    virtual ~UsbHub();

    virtual Type getType();

    virtual void addTransferToTransaction(
        uintptr_t pTransaction, bool bToggle, UsbPid pid, uintptr_t pBuffer,
        size_t nBytes) = 0;

    virtual uintptr_t createTransaction(UsbEndpoint endpointInfo) = 0;

    virtual void doAsync(
        uintptr_t pTransaction, void (*pCallback)(uintptr_t, ssize_t) = 0,
        uintptr_t pParam = 0) = 0;

    virtual void addInterruptInHandler(
        UsbEndpoint endpointInfo, uintptr_t pBuffer, uint16_t nBytes,
        void (*pCallback)(uintptr_t, ssize_t), uintptr_t pParam = 0) = 0;

    bool deviceConnected(uint8_t nPort, UsbSpeed speed);

    void deviceDisconnected(uint8_t nPort);

    ssize_t doSync(uintptr_t nTransaction, uint32_t timeout = 5000);

    // void getDeviceByIds(size_t vendor, size_t product, void
    // (*pCallback)(class UsbDevice *));

    virtual bool portReset(uint8_t nPort, bool bErrorResponse = false) = 0;

    void ignoreConnectionChanges(uint8_t nPort, bool bIgnore = true)
    {
        if (bIgnore)
            m_IgnoredPorts.set(nPort);
        else
            m_IgnoredPorts.clear(nPort);
    }

  private:
    struct SyncParam
    {
        inline SyncParam() : semaphore(0), nResult(-1), timedOut(false)
        {
        }

        Semaphore semaphore;
        ssize_t nResult;

        bool timedOut;
    };

    static void syncCallback(uintptr_t pParam, ssize_t ret);

    ExtensibleBitmap m_UsedAddresses;

  protected:
    ExtensibleBitmap m_IgnoredPorts;
};

#endif