include/usb/udc_lib.h

Go to the documentation of this file.

#ifndef USB_UDC_LIB_H_INCLUDED
#define USB_UDC_LIB_H_INCLUDED

#include <slist.h>
#include <string.h>
#include <types.h>
#include <usb/request.h>

struct udc;
struct usb_setup_req;


extern status_t udc_enter_test_mode(struct udc *udc, unsigned int mode);

extern status_t udc_lib_process_setup_request(struct udc *udc,
                struct usb_setup_req *req);



struct udc_fifo {
        size_t          buf_offset;     
        size_t          size;           

        bool            send_zlp;
};

static inline void udc_fifo_init(struct udc_fifo *fifo, size_t aperture_size)
{
        fifo->buf_offset = 0;
        fifo->size = aperture_size;
        fifo->send_zlp = false;
}

static inline bool udc_fifo_zlp_is_pending(struct udc_fifo *fifo,
                struct usb_request *req)
{
        return fifo->send_zlp;
}

static inline void udc_fifo_zlp_clear_pending(struct udc_fifo *fifo,
                struct usb_request *req)
{
        fifo->send_zlp = false;
}

static inline int udc_fifo_write_data(void *dest, struct udc_fifo *fifo,
                struct slist *done_list, struct usb_request *req)
{
        struct buffer   *buf;
        unsigned int    bytes_written;
        unsigned int    buf_offset;
        unsigned int    fifo_size;

        buf = buf_list_pop_head(&req->buf_list);
        buf_offset = fifo->buf_offset;
        fifo_size = fifo->size;

        for (bytes_written = 0; bytes_written < fifo_size; ) {
                unsigned int    nbytes;
                unsigned int    buf_len;

                buf_len = buf->len;
                nbytes = min_u(fifo_size - bytes_written, buf_len - buf_offset);
                dbg_verbose("udc write: dst %p src %p off %u nbytes %u\n",
                                (char *)dest + bytes_written,
                                buf->addr.ptr, buf_offset, nbytes);
                memcpy((char *)dest + bytes_written,
                                (const char *)buf->addr.ptr + buf_offset,
                                nbytes);

                buf_offset += nbytes;
                bytes_written += nbytes;

                if (buf_offset == buf_len) {
                        buf_offset = 0;
                        slist_insert_tail(done_list, &buf->node);
                        if (slist_is_empty(&req->buf_list)) {
                                if (bytes_written == fifo_size
                                                && test_bit(USB_REQ_SHORT_PKT,
                                                        &req->flags))
                                        fifo->send_zlp = true;
                                goto done;
                        }
                        buf = buf_list_pop_head(&req->buf_list);
                }
        }

        /* Put the last unfinished buffer back on the queue */
        slist_insert_head(&req->buf_list, &buf->node);

done:
        fifo->buf_offset = buf_offset;

        return bytes_written;
}

static inline unsigned int udc_fifo_read_data(const void *src,
                struct udc_fifo *fifo, unsigned int fifo_nbytes,
                struct slist *done_bufs, struct usb_request *req)
{
        struct buffer   *buf;
        unsigned int    bytes_read;
        unsigned int    buf_offset;

        assert(fifo_nbytes <= fifo->size);

        buf = buf_list_pop_head(&req->buf_list);
        buf_offset = fifo->buf_offset;

        for (bytes_read = 0; bytes_read < fifo_nbytes; ) {
                unsigned int    nbytes;
                unsigned int    buf_len;

                buf_len = buf->len;
                nbytes = min_u(fifo_nbytes - bytes_read, buf_len - buf_offset);
                dbg_verbose("udc read: dst %p src %p off %u nbytes %u\n",
                                buf->addr.ptr, (const char *)src + bytes_read,
                                buf_offset, nbytes);
                memcpy((char *)buf->addr.ptr + buf_offset,
                                (const char *)src + bytes_read, nbytes);

                buf_offset += nbytes;
                bytes_read += nbytes;

                if (buf_offset == buf_len) {
                        buf_offset = 0;
                        slist_insert_tail(done_bufs, &buf->node);
                        if (slist_is_empty(&req->buf_list))
                                goto done;
                        buf = buf_list_pop_head(&req->buf_list);
                }
        }

        /* Put the last unfinished buffer back on the queue */
        slist_insert_head(&req->buf_list, &buf->node);

done:
        fifo->buf_offset = buf_offset;

        return bytes_read;
}



#endif /* USB_UDC_LIB_H_INCLUDED */

---