File content as of revision 0:a554658735bf:

/* Copyright (c) 2010-2012 mbed.org, MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software
* and associated documentation files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#ifndef USBHALHOST_H
#define USBHALHOST_H

#include "USBHostTypes.h"
#include "USBHostConf.h"

class USBHostHub;

class USBHALHost {
public:

    /**
    * Constructor
    * init variables and memory where will be stored HCCA, ED and TD
    */
    USBHALHost();
    
    /**
    * Initialize host controller. Enable USB interrupts. This part is not in the constructor because, 
    * this function calls a virtual method if a device is already connected
    */
    void init();
    
    /**
    * reset the root hub
    */
    void resetRootHub();
    
    /**
    * return the value contained in the control HEAD ED register
    *
    * @returns address of the control Head ED
    */
    uint32_t controlHeadED();
    
    /**
    * return the value contained in the bulk HEAD ED register
    *
    * @returns address of the bulk head ED
    */
    uint32_t bulkHeadED();
    
    /**
    * return the value of the head interrupt ED contained in the HCCA
    *
    * @returns address of the head interrupt ED contained in the HCCA
    */
    uint32_t interruptHeadED();
    
    
    /**
    * Update the head ED for control transfers
    */
    void updateControlHeadED(uint32_t addr);
    
    /**
    * Update the head ED for bulk transfers
    */
    void updateBulkHeadED(uint32_t addr);
    
    /**
    * Update the head ED for interrupt transfers
    */
    void updateInterruptHeadED(uint32_t addr);
    
    /* *
    * Enable List for the specified endpoint type
    */
    void enableList(ENDPOINT_TYPE type);
    
    /**
    * Disable List for the specified endpoint type
    */
    bool disableList(ENDPOINT_TYPE type);

protected:
    /**
    * Virtual method called when a device has been connected
    *
    * @param hub hub number of the device
    * @param port port number of the device
    * @param lowSpeed 1 if low speed, 0 otherwise
    * @param hub_parent reference to the hub where the device is connected (NULL if the hub parent is the root hub)
    */
    virtual void deviceConnected(int hub, int port, bool lowSpeed, USBHostHub * hub_parent = NULL) {};
    
    /**
    * Virtual method called when a device has been disconnected
    *
    * @param hub hub number of the device
    * @param port port number of the device
    * @param hub_parent reference to the hub where the device is connected (NULL if the hub parent is the root hub)
    * @param addr list of the TDs which have been completed to dequeue freed TDs
    */
    virtual void deviceDisconnected(int hub, int port, USBHostHub * hub_parent, volatile uint32_t addr) {};
    
    /**
    * Virtual method called when a transfer has been completed
    *
    * @param addr list of the TDs which have been completed
    */
    virtual void transferCompleted(volatile uint32_t addr){};
    
    /**
    * Find a memory section for a new ED
    *
    * @returns the address of this section
    */
    volatile uint8_t * getED();
    
    /**
    * Find a memory section for a new TD
    *
    * @returns the address of this section
    */
    volatile uint8_t * getTD();
    
    /**
    * Release a previous memory section reserved for an ED
    *
    * @param ed address of the ED
    */
    void freeED(volatile uint8_t * ed);
    
    /**
    * Release a previous memory section reserved for an TD
    *
    * @param ed address of the TD
    */
    void freeTD(volatile uint8_t * td);

private:
    static void _usbisr(void);
    void UsbIrqhandler();

    void memInit();

    HCCA volatile * usb_hcca;           //256 bytes aligned
    uint8_t volatile  * usb_edBuf;      //4 bytes aligned
    uint8_t volatile  * usb_tdBuf;      //4 bytes aligned

    static USBHALHost * instHost;
    
    bool volatile  edBufAlloc[MAX_ENDPOINT];
    bool volatile tdBufAlloc[MAX_TD];
};

#endif