Subversion Repositories usb_device_core

//-----------------------------------------------------------------

//                         USB CDC Device SW

//                               V0.1

//                         Ultra-Embedded.com

//                          Copyright 2014

//

//                  Email: admin@ultra-embedded.com

//

//                          License: GPL

// If you would like a version with a more permissive license for use in

// closed source commercial applications please contact me for details.

//-----------------------------------------------------------------

//

// This file is part of USB CDC Device SW.

//

// USB CDC Device SW is free software; you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation; either version 2 of the License, or

// (at your option) any later version.

//

// USB CDC Device SW is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with USB CDC Device SW; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

//-----------------------------------------------------------------

#include <string.h>

#include "usb_device.h"

#include "usb_desc.h"

#include "usb_log.h"

#include "usbf_defs.h"

#include "usbf_hw.h"

//-----------------------------------------------------------------

// Defines:

//-----------------------------------------------------------------

#define USB_CTRL_TX_TIMEOUT     100

#ifndef MAX_CTRL_DATA_LENGTH

    #define MAX_CTRL_DATA_LENGTH    64

#endif

//-----------------------------------------------------------------

// Types

//-----------------------------------------------------------------

// SETUP packet data format

struct device_request

{

        unsigned char   bmRequestType;

        unsigned char   bRequest;

        unsigned short  wValue;

        unsigned short  wIndex;

        unsigned short  wLength;

};

struct control_transfer

{

    // SETUP packet

        struct device_request   request;

    // Data (OUT) stage expected?

    int                     data_expected;

    // Data buffer

    unsigned char           data_buffer[MAX_CTRL_DATA_LENGTH];

    // Data received index

    int                     data_idx;

};

//-----------------------------------------------------------------

// Locals:

//-----------------------------------------------------------------

static struct control_transfer  _ctrl_xfer;

static int                      _remote_wake_enabled;

static FP_CLASS_REQUEST         _class_request;

//-----------------------------------------------------------------

// get_status:

//-----------------------------------------------------------------

static void get_status(struct device_request *request)

{

        unsigned char bRecipient = request->bmRequestType & USB_RECIPIENT_MASK;

    unsigned char data[2] = {0, 0};

    log_printf(USBLOG_INFO, "USB: Get Status %x\n", bRecipient);

        if ( bRecipient == USB_RECIPIENT_DEVICE )

        {

        // Self-powered

                if (!usb_is_bus_powered())

            data[0] |= (1 << 0);

        // Remote Wake-up enabled

                if (_remote_wake_enabled)

            data[0] |= (1 << 1);

                usb_control_send( data, 2, request->wLength );

        }

        else if ( bRecipient == USB_RECIPIENT_INTERFACE )

        {

                usb_control_send( data, 2, request->wLength );

        }

        else if ( bRecipient == USB_RECIPIENT_ENDPOINT )

        {

                if (usbhw_is_endpoint_stalled( request->wIndex & ENDPOINT_ADDR_MASK))

            data[0] = 1;

                usb_control_send( data, 2, request->wLength );

        }

        else

        usbhw_control_endpoint_stall();

}

//-----------------------------------------------------------------

// clear_feature:

//-----------------------------------------------------------------

static void clear_feature(struct device_request *request)

{

        unsigned char bRecipient = request->bmRequestType & USB_RECIPIENT_MASK;

    log_printf(USBLOG_INFO, "USB: Clear Feature %x\n", bRecipient);

        if ( bRecipient == USB_RECIPIENT_DEVICE )

        {

                if ( request->wValue == USB_FEATURE_REMOTE_WAKEUP )

                {

            log_printf(USBLOG_INFO, "USB: Disable remote wake\n");

            _remote_wake_enabled = 0;

                        usbhw_control_endpoint_ack();

                }

                else if ( request->wValue == USB_FEATURE_TEST_MODE )

                {

            log_printf(USBLOG_INFO, "USB: Disable test mode\n");

                        usbhw_control_endpoint_ack();

                }

                else

            usbhw_control_endpoint_stall();

        }

        else if ( bRecipient == USB_RECIPIENT_ENDPOINT &&

                          request->wValue == USB_FEATURE_ENDPOINT_STATE )

        {

                usbhw_control_endpoint_ack();

                usbhw_clear_endpoint_stall( request->wIndex & ENDPOINT_ADDR_MASK );

        }

        else

        usbhw_control_endpoint_stall();

}

//-----------------------------------------------------------------

// set_feature:

//-----------------------------------------------------------------

static void set_feature(struct device_request *request)

{

        unsigned char bRecipient = request->bmRequestType & USB_RECIPIENT_MASK;

    log_printf(USBLOG_INFO, "USB: Set Feature %x\n", bRecipient);

        if ( bRecipient == USB_RECIPIENT_DEVICE )

        {

                if ( request->wValue == USB_FEATURE_REMOTE_WAKEUP )

                {

            log_printf(USBLOG_INFO, "USB: Enable remote wake\n");

            _remote_wake_enabled = 1;

                        usbhw_control_endpoint_ack();

                }

                else if ( request->wValue == USB_FEATURE_TEST_MODE )

                {

            log_printf(USBLOG_INFO, "USB: Enable test mode\n");

                        usbhw_control_endpoint_ack();

                }

                else

            usbhw_control_endpoint_stall();

        }

        else if ( bRecipient == USB_RECIPIENT_ENDPOINT &&

                          request->wValue == USB_FEATURE_ENDPOINT_STATE )

        {

                usbhw_control_endpoint_ack();

                usbhw_set_endpoint_stall(request->wIndex & ENDPOINT_ADDR_MASK);

        }

        else

        usbhw_control_endpoint_stall();

}

//-----------------------------------------------------------------

// set_address:

//-----------------------------------------------------------------

static void set_address(struct device_request *request)

{

        unsigned char addr = (LO_BYTE(request->wValue)) & USB_ADDRESS_MASK;

        usbhw_set_address(addr);

    usbhw_control_endpoint_ack();

    log_printf(USBLOG_INFO, "USB: Set address %x\n", addr);

}

//-----------------------------------------------------------------

// get_descriptor:

//-----------------------------------------------------------------

static void get_descriptor(struct device_request *request)

{

        unsigned char  bDescriptorType = HI_BYTE(request->wValue);

        unsigned char  bDescriptorIndex = LO_BYTE( request->wValue );

        unsigned short wLength = request->wLength;

        unsigned char  bCount = 0;

    unsigned char *desc_ptr;

    desc_ptr = usb_get_descriptor(bDescriptorType, bDescriptorIndex, wLength, &bCount);

    if (desc_ptr)

        usb_control_send(desc_ptr, bCount, request->wLength);

    else

        usbhw_control_endpoint_stall();

}

//-----------------------------------------------------------------

// get_configuration:

//-----------------------------------------------------------------

static void get_configuration(struct device_request *request)

{

        unsigned char conf = usbhw_is_configured() ? 1 : 0;

    log_printf(USBLOG_INFO, "USB: Get configuration %x\n", conf);

        usb_control_send( &conf, 1, request->wLength );

}

//-----------------------------------------------------------------

// set_configuration:

//-----------------------------------------------------------------

static void set_configuration(struct device_request *request)

{

    log_printf(USBLOG_INFO, "USB: set_configuration %x\n", request->wValue);

        if ( request->wValue == 0 )

        {

                usbhw_control_endpoint_ack();

        usbhw_set_configured(0);

        }

    // Only support one configuration for now

        else if ( request->wValue == 1 )

        {

                usbhw_control_endpoint_ack();

        usbhw_set_configured(1);

        }

        else

        usbhw_control_endpoint_stall();

}

//-----------------------------------------------------------------

// get_interface:

//-----------------------------------------------------------------

static void get_interface(struct device_request *request)

{

    log_printf(USBLOG_INFO, "USB: Get interface\n");

        usbhw_control_endpoint_stall();

}

//-----------------------------------------------------------------

// set_interface:

//-----------------------------------------------------------------

static void set_interface(struct device_request *request)

{

    log_printf(USBLOG_INFO, "USB: set_interface %x %x\n", request->wValue, request->wIndex);

        if ( request->wValue == 0 && request->wIndex == 0 )

                usbhw_control_endpoint_ack();

        else

        usbhw_control_endpoint_stall();

}

//-----------------------------------------------------------------

// usb_process_request:

//-----------------------------------------------------------------

static void usb_process_request(struct device_request *request, unsigned char type, unsigned char req, unsigned char *data)

{

        if ( type == USB_STANDARD_REQUEST )

        {

        // Standard requests

        switch (req)

        {

        case REQ_GET_STATUS:

            get_status(request);

            break;

        case REQ_CLEAR_FEATURE:

            clear_feature(request);

            break;

        case REQ_SET_FEATURE:

            set_feature(request);

            break;

        case REQ_SET_ADDRESS:

            set_address(request);

            break;

        case REQ_GET_DESCRIPTOR:

            get_descriptor(request);

            break;

        case REQ_GET_CONFIGURATION:

            get_configuration(request);

            break;

        case REQ_SET_CONFIGURATION:

            set_configuration(request);

            break;

        case REQ_GET_INTERFACE:

            get_interface(request);

            break;

        case REQ_SET_INTERFACE:

            set_interface(request);

            break;

        default:

            log_printf(USBLOG_ERR, "USB: Unknown standard request %x\n", req);

                    usbhw_control_endpoint_stall();

            break;

        }

        }

        else if ( type == USB_VENDOR_REQUEST )

        {

        log_printf(USBLOG_ERR, "Vendor: Unknown command\n");

        // None supported

                usbhw_control_endpoint_stall();

        }

        else if ( type == USB_CLASS_REQUEST && _class_request)

        {

        _class_request(req, request->wValue, request->wIndex, data, request->wLength);

        }

        else

        usbhw_control_endpoint_stall();

}

//-----------------------------------------------------------------

// usb_process_setup: Process SETUP packet

//-----------------------------------------------------------------

static void usb_process_setup(void)

{

    unsigned char type, req;

    unsigned char setup_pkt[EP0_MAX_PACKET_SIZE];

        usbhw_get_rx_data(ENDPOINT_CONTROL, setup_pkt, EP0_MAX_PACKET_SIZE);

    usbhw_clear_rx_ready(ENDPOINT_CONTROL);

    #if (LOG_LEVEL >= USBLOG_SETUP_DATA)

    {

        int i;

        log_printf(USBLOG_SETUP_DATA, "USB: SETUP data %d\n", EP0_MAX_PACKET_SIZE);

        for (i=0;i<EP0_MAX_PACKET_SIZE;i++)

            log_printf(USBLOG_SETUP_DATA, "%02x ", setup_pkt[i]);

        log_printf(USBLOG_SETUP_DATA, "\n");

    }

    #endif

    // Extract packet to local endian format

    _ctrl_xfer.request.bmRequestType = setup_pkt[0];

    _ctrl_xfer.request.bRequest      = setup_pkt[1];

    _ctrl_xfer.request.wValue        = setup_pkt[3];

    _ctrl_xfer.request.wValue      <<= 8;

    _ctrl_xfer.request.wValue       |= setup_pkt[2];

    _ctrl_xfer.request.wIndex        = setup_pkt[5];

    _ctrl_xfer.request.wIndex      <<= 8;

    _ctrl_xfer.request.wIndex       |= setup_pkt[4];

    _ctrl_xfer.request.wLength       = setup_pkt[7];

    _ctrl_xfer.request.wLength     <<= 8;

    _ctrl_xfer.request.wLength      |= setup_pkt[6];

        _ctrl_xfer.data_idx      = 0;

    _ctrl_xfer.data_expected = 0;

        type = _ctrl_xfer.request.bmRequestType & USB_REQUEST_TYPE_MASK;

        req  = _ctrl_xfer.request.bRequest;

    // SETUP - GET

        if (_ctrl_xfer.request.bmRequestType & ENDPOINT_DIR_IN)

        {

        log_printf(USBLOG_SETUP, "USB: SETUP Get wValue=0x%x wIndex=0x%x wLength=%d\n",

                                    _ctrl_xfer.request.wValue,

                                    _ctrl_xfer.request.wIndex,

                                    _ctrl_xfer.request.wLength);

                usb_process_request(&_ctrl_xfer.request, type, req, _ctrl_xfer.data_buffer);

        }

    // SETUP - SET

        else

        {

        // No data

                if ( _ctrl_xfer.request.wLength == 0 )

        {

            log_printf(USBLOG_SETUP, "USB: SETUP Set wValue=0x%x wIndex=0x%x wLength=%d\n",

                                        _ctrl_xfer.request.wValue,

                                        _ctrl_xfer.request.wIndex,

                                        _ctrl_xfer.request.wLength);

            usb_process_request(&_ctrl_xfer.request, type, req, _ctrl_xfer.data_buffer);

        }

        // Data expected

                else

                {

            log_printf(USBLOG_SETUP, "USB: SETUP Set wValue=0x%x wIndex=0x%x wLength=%d [OUT expected]\n",

                                        _ctrl_xfer.request.wValue,

                                        _ctrl_xfer.request.wIndex,

                                        _ctrl_xfer.request.wLength);

                        if ( _ctrl_xfer.request.wLength <= MAX_CTRL_DATA_LENGTH )

            {

                // OUT packets expected to follow containing data

                                _ctrl_xfer.data_expected = 1;

            }

            // Error: Too much data!

                        else

                        {

                log_printf(USBLOG_ERR, "USB: More data than max transfer size\n");

                usbhw_control_endpoint_stall();

                        }

                }

        }

}

//-----------------------------------------------------------------

// usb_process_out: Process OUT (on control EP0)

//-----------------------------------------------------------------

static void usb_process_out(void)

{

        unsigned short received;

    unsigned char type;

    unsigned char req;

    // Error: Not expecting DATA-OUT!

        if (!_ctrl_xfer.data_expected)

        {

        log_printf(USBLOG_ERR, "USB: (EP0) OUT received but not expected, STALL\n");

                usbhw_control_endpoint_stall();

        }

        else

        {

                received = usbhw_get_rx_count( ENDPOINT_CONTROL );

        log_printf(USBLOG_SETUP_OUT, "USB: OUT received (%d bytes)\n", received);

                if ( (_ctrl_xfer.data_idx + received) > MAX_CTRL_DATA_LENGTH )

                {

            log_printf(USBLOG_ERR, "USB: Too much OUT EP0 data %d > %d, STALL\n", (_ctrl_xfer.data_idx + received), MAX_CTRL_DATA_LENGTH);

                        usbhw_control_endpoint_stall();

                }

                else

                {

                        usbhw_get_rx_data(ENDPOINT_CONTROL, &_ctrl_xfer.data_buffer[_ctrl_xfer.data_idx], received);

            usbhw_clear_rx_ready(ENDPOINT_CONTROL);

                        _ctrl_xfer.data_idx += received;

            log_printf(USBLOG_SETUP_OUT, "USB: OUT packet re-assembled %d\n", _ctrl_xfer.data_idx);

            // End of transfer (short transfer received?)

                    if (received < EP0_MAX_PACKET_SIZE || _ctrl_xfer.data_idx >= _ctrl_xfer.request.wLength)

                    {

                // Send ZLP (ACK for Status stage)

                log_printf(USBLOG_SETUP_OUT, "USB: Send ZLP status stage %d %d\n", _ctrl_xfer.data_idx, _ctrl_xfer.request.wLength);

                usbhw_load_tx_buffer( ENDPOINT_CONTROL, 0, 0);

                            while (!usbhw_has_tx_space( ENDPOINT_CONTROL ))

                    ;

                            _ctrl_xfer.data_expected = 0;

                    type = _ctrl_xfer.request.bmRequestType & USB_REQUEST_TYPE_MASK;

                    req  = _ctrl_xfer.request.bRequest;

                            usb_process_request(&_ctrl_xfer.request, type, req, _ctrl_xfer.data_buffer);

                    }

            else

                log_printf(USBLOG_SETUP_OUT, "DEV: More data expected!\n");

        }

        }

}

//-----------------------------------------------------------------

// usb_control_send: Perform a transfer via IN

//-----------------------------------------------------------------

int usb_control_send(unsigned char *buf, int size, int requested_size)

{

        t_time tS;

        int send;

        int remain;

        int count = 0;

    int err = 0;

    log_printf(USBLOG_SETUP_IN, "USB: usb_control_send %d\n", size);

    // Loop until partial packet sent

    do

        {

                remain = size - count;

                send = MIN(remain, EP0_MAX_PACKET_SIZE);

        log_printf(USBLOG_SETUP_IN_DBG, " Remain %d, Send %d\n", remain, send);

        // Do not send ZLP if requested size was size transferred

        if (remain == 0 && size == requested_size)

            break;

                usbhw_load_tx_buffer(ENDPOINT_CONTROL, buf, (unsigned char) send);

                buf += send;

                count += send;

        log_printf(USBLOG_SETUP_IN_DBG, " Sent %d, Remain %d\n", send, (size - count));

                tS = usbhw_timer_now();

                while ( !usbhw_has_tx_space( ENDPOINT_CONTROL ) )

                {

            if (usbhw_timer_diff(usbhw_timer_now(), tS) > USB_CTRL_TX_TIMEOUT)

                        {

                log_printf(USBLOG_ERR, "USB: Timeout sending IN data\n");

                err = 1;

                                break;

                        }

            // Give up on early OUT (STATUS stage)

            if (usbhw_is_rx_ready(ENDPOINT_CONTROL))

            {

                log_printf(USBLOG_ERR, "USB: Early ACK received...\n");

                break;

            }

                }

        }

    while (send >= EP0_MAX_PACKET_SIZE);

    if (!err)

    {

        log_printf(USBLOG_SETUP_IN, "USB: Sent total %d\n", count);

            // Wait for ACK from host

            tS = usbhw_timer_now();

            do

        {

            if (usbhw_timer_diff(usbhw_timer_now(), tS) > USB_CTRL_TX_TIMEOUT)

                    {

                            log_printf(USBLOG_ERR, "USB: ACK not received\n");

                err = 1;

                            break;

                    }

            }

        while (!usbhw_is_rx_ready(ENDPOINT_CONTROL));

        usbhw_clear_rx_ready(ENDPOINT_CONTROL);

        if (!err)

        {

            log_printf(USBLOG_SETUP_IN, "USB: ACK received\n");

        }

    }

    return !err;

}

//-----------------------------------------------------------------

// usbf_init:

//-----------------------------------------------------------------

void usbf_init(unsigned int base, FP_BUS_RESET bus_reset, FP_CLASS_REQUEST class_request)

{

    _class_request = class_request;

    usbhw_init(base, bus_reset, usb_process_setup, usb_process_out);

}