deon/chopstx
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

USB for FS-BB48

Browse Source
This commit is contained in:
NIIBE Yutaka
2016-06-08 15:43:11 +09:00
parent 5f1c26ff17
commit d061e6f931
7 changed files with 504 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
ChangeLog
View File

@@ -1,10 +1,14 @@
2016-06-08 NIIBE Yutaka <gniibe@fsij.org>
* mcu/usb-stm32f103.c: Rewrite to be event driven API.
* mcu/usb-mkl27z.c: Likewise.
* example-cdc/usb-cdc.c: Update to new USB API.
* example-fs-bb48/usb-cdc.c: Likewise.
* example-cdc/tty.h: Change tty API to be C string (char*)
friendly.
* example-fs-bb48/tty.h: Ditto.
2016-06-02 Niibe Yutaka <gniibe@fsij.org>

18
example-fs-bb48/command.c
View File

@@ -23,7 +23,7 @@ struct command_table
static void
put_line (struct tty *tty, const char *line)
{
tty_send (tty, (uint8_t *)line, strlen (line));
tty_send (tty, line, strlen (line));
}
static const char *help_string =
@@ -203,7 +203,7 @@ cmd_mdw (struct tty *tty, const char *line)
*s++ = '\r';
*s++ = '\n';
tty_send (tty, (uint8_t *)output, s - output);
tty_send (tty, output, s - output);
}
}
@@ -326,7 +326,7 @@ cmd_crc32 (struct tty *tty, const char *line)
s = compose_hex (string, v);
*s++ = '\r';
*s++ = '\n';
tty_send (tty, (uint8_t *)string, sizeof (string));
tty_send (tty, string, sizeof (string));
}
#endif
@@ -369,7 +369,7 @@ cmd_adc (struct tty *tty, const char *line)
{
*s++ = '\r';
*s++ = '\n';
tty_send (tty, (uint8_t *)output, s - output);
tty_send (tty, output, s - output);
s = output;
if (i >= 64)
break;
@@ -393,14 +393,14 @@ cmd_sysinfo (struct tty *tty, const char *line)
*s++ = sys_version[6];
*s++ = '\r';
*s++ = '\n';
tty_send (tty, (uint8_t *)output, s - output);
tty_send (tty, output, s - output);
memcpy (output, "Board ID: ", 10);
s = output + 10;
s = compose_hex (s, sys_board_id);
*s++ = '\r';
*s++ = '\n';
tty_send (tty, (uint8_t *)output, s - output);
tty_send (tty, output, s - output);
memcpy (output, "Board name: ", 12);
s = output + 12;
@@ -412,7 +412,7 @@ cmd_sysinfo (struct tty *tty, const char *line)
*s++ = '\r';
*s++ = '\n';
tty_send (tty, (uint8_t *)output, s - output);
tty_send (tty, output, s - output);
}
@@ -470,10 +470,10 @@ cmd_dispatch (struct tty *tty, const char *line)
(*command_table[i].handler) (tty, p);
else
{
uint8_t crlf[] = { '\r', '\n' };
char crlf[] = { '\r', '\n' };
put_line (tty, "No such command: ");
tty_send (tty, (const uint8_t *)line, n);
tty_send (tty, line, n);
tty_send (tty, crlf, sizeof (crlf));
}
}

4
example-fs-bb48/sample.c
View File

@@ -151,7 +151,7 @@ main (int argc, const char *argv[])
m = 50;
while (1)
{
uint8_t s[LINEBUFSIZE];
char s[LINEBUFSIZE];
connection_loop:
u = 1;
@@ -175,7 +175,7 @@ main (int argc, const char *argv[])
uint32_t usec;
/* Prompt */
if (tty_send (tty, (uint8_t *)"> ", 2) < 0)
if (tty_send (tty, "> ", 2) < 0)
break;
usec = 3000000; /* 3.0 seconds */

4
example-fs-bb48/tty.h
View File

@@ -5,5 +5,5 @@ struct tty;
struct tty *tty_open (void);
void tty_wait_configured (struct tty *tty);
void tty_wait_connection (struct tty *tty);
int tty_send (struct tty *tty, const uint8_t *buf, int count);
int tty_recv (struct tty *tty, uint8_t *buf, uint32_t *timeout);
int tty_send (struct tty *tty, const char *buf, int count);
int tty_recv (struct tty *tty, char *buf, uint32_t *timeout);

342
example-fs-bb48/usb-cdc.c
View File

@@ -31,7 +31,7 @@ static const struct line_coding line_coding0 = {
*
* In that case, add argument to TTY_OPEN function and
* modify TTY_GET function to get the TTY structure. Functions which
* directy accesses TTY0 (usb_cb_device_reset and usb_cb_handle_event)
* directy accesses TTY0 (usb_device_reset and usb_set_configuration)
* should be modified, too.
*
* Modification of TTY_MAIN thread will be also needed to echo back
@@ -231,13 +231,13 @@ static const uint8_t vcom_string3[28] = {
#define NUM_INTERFACES 2
void
usb_cb_device_reset (void)
static void
usb_device_reset (struct usb_dev *dev)
{
usb_lld_reset (VCOM_FEATURE_BUS_POWERED);
usb_lld_reset (dev, VCOM_FEATURE_BUS_POWERED);
/* Initialize Endpoint 0 */
usb_lld_setup_endp (ENDP0, 1, 1);
usb_lld_setup_endp (dev, ENDP0, 1, 1);
chopstx_mutex_lock (&tty0.mtx);
tty0.inputline_len = 0;
@@ -253,13 +253,15 @@ usb_cb_device_reset (void)
#define CDC_CTRL_DTR 0x0001
void
usb_cb_ctrl_write_finish (uint8_t req, uint8_t req_no, struct req_args *arg)
static void
usb_ctrl_write_finish (struct usb_dev *dev)
{
uint8_t type_rcp = req & (REQUEST_TYPE|RECIPIENT);
struct device_req *arg = &dev->dev_req;
uint8_t type_rcp = arg->type & (REQUEST_TYPE|RECIPIENT);
if (type_rcp == (CLASS_REQUEST | INTERFACE_RECIPIENT) && arg->index == 0
&& USB_SETUP_SET (req) && req_no == USB_CDC_REQ_SET_CONTROL_LINE_STATE)
&& USB_SETUP_SET (arg->type)
&& arg->request == USB_CDC_REQ_SET_CONTROL_LINE_STATE)
{
struct tty *t = tty_get (arg->index, 0);
@@ -274,58 +276,64 @@ usb_cb_ctrl_write_finish (uint8_t req, uint8_t req_no, struct req_args *arg)
static int
vcom_port_data_setup (uint8_t req, uint8_t req_no, struct req_args *arg)
vcom_port_data_setup (struct usb_dev *dev)
{
if (USB_SETUP_GET (req))
struct device_req *arg = &dev->dev_req;
if (USB_SETUP_GET (arg->type))
{
struct tty *t = tty_get (arg->index, 0);
if (req_no == USB_CDC_REQ_GET_LINE_CODING)
return usb_lld_reply_request (&t->line_coding,
sizeof (struct line_coding), arg);
if (arg->request == USB_CDC_REQ_GET_LINE_CODING)
return usb_lld_reply_request (dev, &t->line_coding,
sizeof (struct line_coding));
}
else /* USB_SETUP_SET (req) */
{
if (req_no == USB_CDC_REQ_SET_LINE_CODING
if (arg->request == USB_CDC_REQ_SET_LINE_CODING
&& arg->len == sizeof (struct line_coding))
{
struct tty *t = tty_get (arg->index, 0);
usb_lld_set_data_to_recv (&t->line_coding,
sizeof (struct line_coding));
return USB_SUCCESS;
return usb_lld_set_data_to_recv (dev, &t->line_coding,
sizeof (struct line_coding));
}
else if (req_no == USB_CDC_REQ_SET_CONTROL_LINE_STATE)
return USB_SUCCESS;
else if (arg->request == USB_CDC_REQ_SET_CONTROL_LINE_STATE)
return 0;
}
return USB_UNSUPPORT;
return -1;
}
int
usb_cb_setup (uint8_t req, uint8_t req_no, struct req_args *arg)
static int
usb_setup (struct usb_dev *dev)
{
uint8_t type_rcp = req & (REQUEST_TYPE|RECIPIENT);
struct device_req *arg = &dev->dev_req;
uint8_t type_rcp = arg->type & (REQUEST_TYPE|RECIPIENT);
if (type_rcp == (CLASS_REQUEST | INTERFACE_RECIPIENT) && arg->index == 0)
return vcom_port_data_setup (req, req_no, arg);
return vcom_port_data_setup (dev);
return USB_UNSUPPORT;
return -1;
}
int
usb_cb_get_descriptor (uint8_t rcp, uint8_t desc_type, uint8_t desc_index,
struct req_args *arg)
static int
usb_get_descriptor (struct usb_dev *dev)
{
struct device_req *arg = &dev->dev_req;
uint8_t rcp = arg->type & RECIPIENT;
uint8_t desc_type = (arg->value >> 8);
uint8_t desc_index = (arg->value & 0xff);
if (rcp != DEVICE_RECIPIENT)
return USB_UNSUPPORT;
return -1;
if (desc_type == DEVICE_DESCRIPTOR)
return usb_lld_reply_request (vcom_device_desc, sizeof (vcom_device_desc),
arg);
return usb_lld_reply_request (dev,
vcom_device_desc, sizeof (vcom_device_desc));
else if (desc_type == CONFIG_DESCRIPTOR)
return usb_lld_reply_request (vcom_config_desc, sizeof (vcom_config_desc),
arg);
return usb_lld_reply_request (dev,
vcom_config_desc, sizeof (vcom_config_desc));
else if (desc_type == STRING_DESCRIPTOR)
{
const uint8_t *str;
@@ -350,22 +358,23 @@ usb_cb_get_descriptor (uint8_t rcp, uint8_t desc_type, uint8_t desc_index,
size = sizeof (vcom_string3);
break;
default:
return USB_UNSUPPORT;
return -1;
}
return usb_lld_reply_request (str, size, arg);
return usb_lld_reply_request (dev, str, size);
}
return USB_UNSUPPORT;
return -1;
}
static void
vcom_setup_endpoints_for_interface (uint16_t interface, int stop)
vcom_setup_endpoints_for_interface (struct usb_dev *dev,
uint16_t interface, int stop)
{
if (interface == 0)
{
if (!stop)
usb_lld_setup_endp (ENDP2, 0, 1);
usb_lld_setup_endp (dev, ENDP2, 0, 1);
else
usb_lld_stall (ENDP2);
}
@@ -373,8 +382,8 @@ vcom_setup_endpoints_for_interface (uint16_t interface, int stop)
{
if (!stop)
{
usb_lld_setup_endp (ENDP1, 0, 1);
usb_lld_setup_endp (ENDP3, 1, 0);
usb_lld_setup_endp (dev, ENDP1, 0, 1);
usb_lld_setup_endp (dev, ENDP3, 1, 0);
/* Start with no data receiving (ENDP3 not enabled)*/
}
else
@@ -385,85 +394,86 @@ vcom_setup_endpoints_for_interface (uint16_t interface, int stop)
}
}
int
usb_cb_handle_event (uint8_t event_type, uint16_t value)
static int
usb_set_configuration (struct usb_dev *dev)
{
int i;
uint8_t current_conf;
switch (event_type)
current_conf = usb_lld_current_configuration (dev);
if (current_conf == 0)
{
case USB_EVENT_ADDRESS:
if (dev->dev_req.value != 1)
return -1;
usb_lld_set_configuration (dev, 1);
for (i = 0; i < NUM_INTERFACES; i++)
vcom_setup_endpoints_for_interface (dev, i, 0);
chopstx_mutex_lock (&tty0.mtx);
tty0.device_state = CONFIGURED;
chopstx_cond_signal (&tty0.cnd);
chopstx_mutex_unlock (&tty0.mtx);
}
else if (current_conf != dev->dev_req.value)
{
if (dev->dev_req.value != 0)
return -1;
usb_lld_set_configuration (dev, 0);
for (i = 0; i < NUM_INTERFACES; i++)
vcom_setup_endpoints_for_interface (dev, i, 1);
chopstx_mutex_lock (&tty0.mtx);
tty0.device_state = ADDRESSED;
chopstx_cond_signal (&tty0.cnd);
chopstx_mutex_unlock (&tty0.mtx);
return USB_SUCCESS;
case USB_EVENT_CONFIG:
current_conf = usb_lld_current_configuration ();
if (current_conf == 0)
{
if (value != 1)
return USB_UNSUPPORT;
usb_lld_set_configuration (1);
for (i = 0; i < NUM_INTERFACES; i++)
vcom_setup_endpoints_for_interface (i, 0);
chopstx_mutex_lock (&tty0.mtx);
tty0.device_state = CONFIGURED;
chopstx_mutex_unlock (&tty0.mtx);
}
else if (current_conf != value)
{
if (value != 0)
return USB_UNSUPPORT;
usb_lld_set_configuration (0);
for (i = 0; i < NUM_INTERFACES; i++)
vcom_setup_endpoints_for_interface (i, 1);
chopstx_mutex_lock (&tty0.mtx);
tty0.device_state = ADDRESSED;
chopstx_mutex_unlock (&tty0.mtx);
}
/* Do nothing when current_conf == value */
return USB_SUCCESS;
default:
break;
}
return USB_UNSUPPORT;
return 0;
}
int
usb_cb_interface (uint8_t cmd, struct req_args *arg)
static int
usb_set_interface (struct usb_dev *dev)
{
const uint8_t zero = 0;
uint16_t interface = arg->index;
uint16_t alt = arg->value;
uint16_t interface = dev->dev_req.index;
uint16_t alt = dev->dev_req.value;
if (interface >= NUM_INTERFACES)
return USB_UNSUPPORT;
return -1;
switch (cmd)
if (alt != 0)
return -1;
else
{
case USB_SET_INTERFACE:
if (alt != 0)
return USB_UNSUPPORT;
else
{
vcom_setup_endpoints_for_interface (interface, 0);
return USB_SUCCESS;
}
case USB_GET_INTERFACE:
return usb_lld_reply_request (&zero, 1, arg);
default:
case USB_QUERY_INTERFACE:
return USB_SUCCESS;
vcom_setup_endpoints_for_interface (dev, interface, 0);
return 0;
}
}
static int
usb_get_interface (struct usb_dev *dev)
{
const uint8_t zero = 0;
uint16_t interface = dev->dev_req.index;
if (interface >= NUM_INTERFACES)
return -1;
/* We don't have alternate interface, so, always return 0. */
return usb_lld_reply_request (dev, &zero, 1);
}
static int
usb_get_status_interface (struct usb_dev *dev)
{
const uint16_t status_info = 0;
uint16_t interface = dev->dev_req.index;
if (interface >= NUM_INTERFACES)
return -1;
return usb_lld_reply_request (dev, &status_info, 2);
}
/*
* Put a character into the ring buffer to be send back.
@@ -511,8 +521,8 @@ tty_echo_char (struct tty *t, int c)
put_char_to_ringbuffer (t, c);
}
void
usb_cb_tx_done (uint8_t ep_num, uint32_t len)
static void
usb_tx_done (uint8_t ep_num, uint16_t len)
{
struct tty *t = tty_get (-1, ep_num);
@@ -594,17 +604,16 @@ tty_input_char (struct tty *t, int c)
return r;
}
void
usb_cb_rx_ready (uint8_t ep_num)
static void
usb_rx_ready (uint8_t ep_num, uint16_t len)
{
struct tty *t = tty_get (-1, ep_num);
if (ep_num == ENDP3)
{
int i, r;
int i;
r = usb_lld_rx_data_len (ENDP3);
for (i = 0; i < r; i++)
for (i = 0; i < len; i++)
if (tty_input_char (t, t->recv_buf0[i]))
break;
@@ -646,6 +655,8 @@ static void *
tty_main (void *arg)
{
struct tty *t = arg;
struct usb_dev dev;
int e;
#if defined(OLDER_SYS_H)
/*
@@ -654,9 +665,9 @@ tty_main (void *arg)
*
* When USB interrupt occurs between usb_lld_init (which assumes
* ISR) and chopstx_claim_irq (which clears pending interrupt),
* invocation of usb_interrupt_handler won't occur.
* invocation of usb_lld_event_handler won't occur.
*
* Calling usb_interrupt_handler is no harm even if there were no
* Calling usb_lld_event_handler is no harm even if there were no
* interrupts, thus, we call it unconditionally here, just in case
* if there is a request.
*
@@ -665,19 +676,117 @@ tty_main (void *arg)
* chopstx_claim_irq after usb_lld_init overrides that.
*
*/
usb_lld_init (VCOM_FEATURE_BUS_POWERED);
usb_lld_init (&dev, VCOM_FEATURE_BUS_POWERED);
chopstx_claim_irq (&usb_intr, INTR_REQ_USB);
usb_interrupt_handler ();
goto event_handle;
#else
chopstx_claim_irq (&usb_intr, INTR_REQ_USB);
usb_lld_init (VCOM_FEATURE_BUS_POWERED);
usb_lld_init (&dev, VCOM_FEATURE_BUS_POWERED);
#endif
while (1)
{
chopstx_poll (NULL, 1, &usb_intr);
if (usb_intr.ready)
usb_interrupt_handler ();
{
uint8_t ep_num;
#if defined(OLDER_SYS_H)
event_handle:
#endif
/*
* When interrupt is detected, call usb_lld_event_handler.
* The event may be one of following:
* (1) Transfer to endpoint (bulk or interrupt)
* In this case EP_NUM is encoded in the variable E.
* (2) "NONE" event: some trasfer was done, but all was
* done by lower layer, no other work is needed in
* upper layer.
* (3) Device events: Reset or Suspend
* (4) Device requests to the endpoint zero.
*
*/
e = usb_lld_event_handler (&dev);
ep_num = USB_EVENT_ENDP (e);
if (ep_num != 0)
{
if (USB_EVENT_TXRX (e))
usb_tx_done (ep_num, USB_EVENT_LEN (e));
else
usb_rx_ready (ep_num, USB_EVENT_LEN (e));
}
else
switch (USB_EVENT_ID (e))
{
case USB_EVENT_DEVICE_RESET:
usb_device_reset (&dev);
continue;
case USB_EVENT_GET_DESCRIPTOR:
if (usb_get_descriptor (&dev) < 0)
usb_lld_ctrl_error (&dev);
continue;
/* The addres is assigned to the device. We don't
* need to do anything for this actually, but in this
* application, we maintain the USB status of the
* device. Usually, just "continue" as EVENT_NONE is
* OK.
*/
case USB_EVENT_DEVICE_ADDRESSED:
chopstx_mutex_lock (&tty0.mtx);
tty0.device_state = ADDRESSED;
chopstx_cond_signal (&tty0.cnd);
chopstx_mutex_unlock (&tty0.mtx);
continue;
case USB_EVENT_SET_CONFIGURATION:
if (usb_set_configuration (&dev) < 0)
usb_lld_ctrl_error (&dev);
else
usb_lld_ctrl_good (&dev);
continue;
case USB_EVENT_SET_INTERFACE:
if (usb_set_interface (&dev) < 0)
usb_lld_ctrl_error (&dev);
else
usb_lld_ctrl_good (&dev);
continue;
/* Non standard device request. */
case USB_EVENT_CTRL_REQUEST:
if (usb_setup (&dev) < 0)
usb_lld_ctrl_error (&dev);
else
usb_lld_ctrl_good (&dev);
continue;
/* Control WRITE transfer finished. */
case USB_EVENT_CTRL_WRITE_FINISH:
usb_ctrl_write_finish (&dev);
continue;
case USB_EVENT_GET_STATUS_INTERFACE:
if (usb_get_status_interface (&dev) < 0)
usb_lld_ctrl_error (&dev);
continue;
case USB_EVENT_GET_INTERFACE:
if (usb_get_interface (&dev) < 0)
usb_lld_ctrl_error (&dev);
continue;
case USB_EVENT_NONE:
case USB_EVENT_SET_FEATURE_DEVICE:
case USB_EVENT_SET_FEATURE_ENDPOINT:
case USB_EVENT_CLEAR_FEATURE_DEVICE:
case USB_EVENT_CLEAR_FEATURE_ENDPOINT:
case USB_EVENT_DEVICE_SUSPEND:
default:
continue;
}
}
chopstx_mutex_lock (&t->mtx);
if (t->device_state == CONFIGURED && t->flag_connected
@@ -720,8 +829,7 @@ tty_wait_connection (struct tty *t)
t->flag_input_avail = 0;
t->send_head = t->send_tail = 0;
t->inputline_len = 0;
/* Accept input for line */
usb_lld_rx_enable_buf (ENDP3, t->recv_buf0, 64);
usb_lld_rx_enable_buf (ENDP3, t->recv_buf0, 64); /* Accept input for line */
chopstx_mutex_unlock (&t->mtx);
}
@@ -738,10 +846,10 @@ check_tx (struct tty *t)
}
int
tty_send (struct tty *t, const uint8_t *buf, int len)
tty_send (struct tty *t, const char *buf, int len)
{
int r;
const uint8_t *p;
const char *p;
int count;
p = buf;
@@ -800,7 +908,7 @@ check_rx (void *arg)
*
*/
int
tty_recv (struct tty *t, uint8_t *buf, uint32_t *timeout)
tty_recv (struct tty *t, char *buf, uint32_t *timeout)
{
int r;
chopstx_poll_cond_t poll_desc;

546
mcu/usb-mkl27z.c
View File

@@ -32,6 +32,9 @@
#include "usb_lld.h"
#define DATA0 0
#define DATA1 1
struct endpoint_ctl {
uint32_t rx_odd: 1;
uint32_t tx_odd: 1;
@@ -135,12 +138,6 @@ extern uint8_t __usb_bdt__;
static struct BD *const BD_table = (struct BD *const)&__usb_bdt__;
static uint8_t setup[8];
/* bmRequestType, bRequest */
/* Value: 2-byte */
/* Index: 2-byte */
/* Length: 2-byte */
static void
kl27z_usb_init (void)
{
@@ -183,11 +180,11 @@ kl27z_set_daddr (uint8_t daddr)
}
static void
kl27z_prepare_ep0_setup (void)
kl27z_prepare_ep0_setup (struct usb_dev *dev)
{
/* Endpoint 0, TX=0. */
BD_table[ep[0].rx_odd].ctrl = 0x00080088; /* Len=8, OWN=1, DATA01=0, DTS=1 */
BD_table[ep[0].rx_odd].buf = setup;
BD_table[ep[0].rx_odd].buf = &dev->dev_req;
BD_table[!ep[0].rx_odd].ctrl = 0x0000; /* OWN=0 */
BD_table[!ep[0].rx_odd].buf = NULL;
@@ -296,17 +293,11 @@ enum STANDARD_REQUESTS {
enum FEATURE_SELECTOR {
ENDPOINT_STALL,
DEVICE_REMOTE_WAKEUP
FEATURE_ENDPOINT_HALT=0,
FEATURE_DEVICE_REMOTE_WAKEUP=1
};
struct data_ctl {
uint8_t *addr;
uint16_t len;
uint8_t require_zlp;
};
/* The state machine states of a control pipe */
enum {
WAIT_SETUP,
@@ -319,30 +310,7 @@ enum {
PAUSE
};
struct device_ctl {
/* control pipe state */
uint8_t state;
uint32_t tkdone;
uint32_t reset;
uint32_t error;
uint32_t stall;
uint32_t send;
uint32_t recv;
/* Device specific settings */
uint8_t configuration;
uint8_t feature;
};
static struct device_ctl device_ctl;
static struct data_ctl data_ctl;
static struct device_ctl *const dev_p = &device_ctl;
static struct data_ctl *const data_p = &data_ctl;
static void handle_transaction (uint8_t stat);
static int handle_transaction (struct usb_dev *dev, uint8_t stat);
void
usb_lld_stall (int n)
@@ -352,16 +320,30 @@ usb_lld_stall (int n)
void
usb_lld_init (uint8_t feature)
usb_lld_ctrl_error (struct usb_dev *dev)
{
dev_p->state = WAIT_SETUP;
dev_p->tkdone = 0;
dev_p->reset = 0;
dev_p->error = 0;
dev_p->stall = 0;
dev->state = STALLED;
kl27z_ep_stall (ENDP0);
}
usb_lld_set_configuration (0);
dev_p->feature = feature;
void
usb_lld_ctrl_good (struct usb_dev *dev)
{
if (dev->dev_req.len == 0)
{
/* Zero length packet for ACK. */
dev->state = WAIT_STATUS_IN;
kl27z_prepare_ep0_in (&dev->dev_req, 0, DATA1);
}
}
void
usb_lld_init (struct usb_dev *dev, uint8_t feature)
{
usb_lld_set_configuration (dev, 0);
dev->feature = feature;
dev->state = WAIT_SETUP;
kl27z_set_daddr (0);
kl27z_usb_init ();
@@ -376,8 +358,12 @@ usb_lld_init (uint8_t feature)
| USB_IS_ERROR | USB_IS_USBRST;
}
void
usb_interrupt_handler (void)
#define USB_MAKE_EV(event) (event<<24)
#define USB_MAKE_TXRX(ep_num,txrx,len) ((txrx? (1<<23):0)|(ep_num<<16)|len)
int
usb_lld_event_handler (struct usb_dev *dev)
{
uint8_t istat_value = USB_CTRL1->ISTAT;
uint8_t stat = USB_CTRL1->STAT;
@@ -385,20 +371,14 @@ usb_interrupt_handler (void)
if ((istat_value & USB_IS_USBRST))
{
USB_CTRL1->ISTAT = USB_IS_USBRST;
usb_cb_device_reset ();
dev_p->reset++;
return USB_MAKE_EV (USB_EVENT_DEVICE_RESET);
}
else if ((istat_value & USB_IS_TOKDNE))
{
handle_transaction (stat);
dev_p->tkdone++;
}
return handle_transaction (dev, stat);
else if ((istat_value & USB_IS_ERROR))
{ /* Clear Errors. */
USB_CTRL1->ERRSTAT = USB_CTRL1->ERRSTAT;
USB_CTRL1->ISTAT = USB_IS_ERROR;
/*reset???*/
dev_p->error++;
}
else if ((istat_value & USB_IS_STALL))
{
@@ -406,22 +386,22 @@ usb_interrupt_handler (void)
if (kl27z_ep_is_stall (0))
{ /* It's endpoint 0, recover from erorr. */
dev_p->state = WAIT_SETUP;
dev->state = WAIT_SETUP;
kl27z_ep_clear_stall (0);
kl27z_prepare_ep0_setup ();
kl27z_prepare_ep0_setup (dev);
}
USB_CTRL1->ISTAT = USB_IS_STALL;
dev_p->stall++;
}
return 0;
}
#define DATA0 0
#define DATA1 1
static void
handle_datastage_out (uint8_t stat)
handle_datastage_out (struct usb_dev *dev, uint8_t stat)
{
struct ctrl_data *data_p = &dev->ctrl_data;
int odd = (stat >> 2)&1;
int data01 = !((BD_table[odd].ctrl >> 6)&1);
uint32_t len = (BD_table[odd].ctrl >> 16)&0x3ff;
@@ -436,43 +416,44 @@ handle_datastage_out (uint8_t stat)
if (data_p->len == 0)
{
/* No more data to receive, proceed to send acknowledge for IN. */
dev_p->state = WAIT_STATUS_IN;
kl27z_prepare_ep0_in (setup, 0, DATA1);
dev->state = WAIT_STATUS_IN;
kl27z_prepare_ep0_in (&dev->dev_req, 0, DATA1);
}
else
{
dev_p->state = OUT_DATA;
dev->state = OUT_DATA;
kl27z_prepare_ep0_out (data_p->addr, len, data01);
}
}
static void
handle_datastage_in (uint8_t stat)
handle_datastage_in (struct usb_dev *dev, uint8_t stat)
{
struct ctrl_data *data_p = &dev->ctrl_data;
int odd = (stat >> 2)&1;
int data01 = !((BD_table[2+odd].ctrl >> 6)&1);
uint32_t len = USB_MAX_PACKET_SIZE;
if ((data_p->len == 0) && (dev_p->state == LAST_IN_DATA))
if ((data_p->len == 0) && (dev->state == LAST_IN_DATA))
{
if (data_p->require_zlp)
{
data_p->require_zlp = 0;
/* No more data to send. Send empty packet */
kl27z_prepare_ep0_in (setup, 0, data01);
kl27z_prepare_ep0_in (&dev->dev_req, 0, data01);
}
else
{
/* No more data to send, proceed to receive OUT acknowledge. */
dev_p->state = WAIT_STATUS_OUT;
kl27z_prepare_ep0_out (setup, 8, DATA1);
dev->state = WAIT_STATUS_OUT;
kl27z_prepare_ep0_out (&dev->dev_req, 8, DATA1);
}
return;
}
dev_p->state = (data_p->len <= len) ? LAST_IN_DATA : IN_DATA;
dev->state = (data_p->len <= len) ? LAST_IN_DATA : IN_DATA;
if (len > data_p->len)
len = data_p->len;
@@ -482,31 +463,32 @@ handle_datastage_in (uint8_t stat)
data_p->addr += len;
}
typedef int (*HANDLER) (uint8_t req, struct req_args *arg);
typedef int (*HANDLER) (struct usb_dev *dev);
static int
std_none (uint8_t req, struct req_args *arg)
std_none (struct usb_dev *dev)
{
(void)req; (void)arg;
return USB_UNSUPPORT;
(void)dev;
return -1;
}
static int
std_get_status (uint8_t req, struct req_args *arg)
std_get_status (struct usb_dev *dev)
{
uint8_t rcp = req & RECIPIENT;
struct device_req *arg = &dev->dev_req;
uint8_t rcp = arg->type & RECIPIENT;
uint16_t status_info = 0;
if (arg->value != 0 || arg->len != 2 || (arg->index >> 8) != 0
|| USB_SETUP_SET (req))
return USB_UNSUPPORT;
|| USB_SETUP_SET (arg->type))
return -1;
if (rcp == DEVICE_RECIPIENT)
{
if (arg->index == 0)
{
/* Get Device Status */
uint8_t feature = dev_p->feature;
uint8_t feature = dev->feature;
/* Remote Wakeup enabled */
if ((feature & (1 << 5)))
@@ -520,319 +502,322 @@ std_get_status (uint8_t req, struct req_args *arg)
else /* Self-powered */
status_info &= ~1;
return usb_lld_reply_request (&status_info, 2, arg);
return usb_lld_reply_request (dev, &status_info, 2);
}
}
else if (rcp == INTERFACE_RECIPIENT)
{
int r;
if (dev->configuration == 0)
return -1;
if (dev_p->configuration == 0)
return USB_UNSUPPORT;
r = usb_cb_interface (USB_QUERY_INTERFACE, arg);
if (r != USB_SUCCESS)
return USB_UNSUPPORT;
return usb_lld_reply_request (&status_info, 2, arg);
return USB_EVENT_GET_STATUS_INTERFACE;
}
else if (rcp == ENDPOINT_RECIPIENT)
{
uint8_t n = (arg->index & 0x0f);
if ((arg->index & 0x70) || n == ENDP0)
return USB_UNSUPPORT;
return -1;
if (kl27z_ep_is_disabled (n))
return USB_UNSUPPORT;
return -1;
status_info = kl27z_ep_is_stall (n);
return usb_lld_reply_request (&status_info, 2, arg);
return usb_lld_reply_request (dev, &status_info, 2);
}
return USB_UNSUPPORT;
return -1;
}
static int
std_clear_feature (uint8_t req, struct req_args *arg)
std_clear_feature (struct usb_dev *dev)
{
uint8_t rcp = req & RECIPIENT;
struct device_req *arg = &dev->dev_req;
uint8_t rcp = arg->type & RECIPIENT;
if (USB_SETUP_GET (req))
return USB_UNSUPPORT;
if (USB_SETUP_GET (arg->type))
return -1;
if (rcp == DEVICE_RECIPIENT)
{
if (arg->len != 0 || arg->index != 0)
return USB_UNSUPPORT;
return -1;
if (arg->value == DEVICE_REMOTE_WAKEUP)
if (arg->value == FEATURE_DEVICE_REMOTE_WAKEUP)
{
dev_p->feature &= ~(1 << 5);
return USB_SUCCESS;
dev->feature &= ~(1 << 5);
return USB_EVENT_CLEAR_FEATURE_DEVICE;
}
}
else if (rcp == ENDPOINT_RECIPIENT)
{
uint8_t n = (arg->index & 0x0f);
if (dev_p->configuration == 0)
return USB_UNSUPPORT;
if (dev->configuration == 0)
return -1;
if (arg->len != 0 || (arg->index >> 8) != 0
|| arg->value != ENDPOINT_STALL || n == ENDP0)
return USB_UNSUPPORT;
|| arg->value != FEATURE_ENDPOINT_HALT || n == ENDP0)
return -1;
if (kl27z_ep_is_disabled (n))
return USB_UNSUPPORT;
return -1;
kl27z_ep_clear_dtog ((arg->index & 0x80) == 0, n);
// event??
return USB_SUCCESS;
return USB_EVENT_CLEAR_FEATURE_ENDPOINT;
}
return USB_UNSUPPORT;
return -1;
}
static int
std_set_feature (uint8_t req, struct req_args *arg)
std_set_feature (struct usb_dev *dev)
{
uint8_t rcp = req & RECIPIENT;
struct device_req *arg = &dev->dev_req;
uint8_t rcp = arg->type & RECIPIENT;
if (USB_SETUP_GET (req))
return USB_UNSUPPORT;
if (USB_SETUP_GET (arg->type))
return -1;
if (rcp == DEVICE_RECIPIENT)
{
if (arg->len != 0 || arg->index != 0)
return USB_UNSUPPORT;
return -1;
if (arg->value == DEVICE_REMOTE_WAKEUP)
if (arg->value == FEATURE_DEVICE_REMOTE_WAKEUP)
{
dev_p->feature |= 1 << 5;
// event??
return USB_SUCCESS;
dev->feature |= 1 << 5;
return USB_EVENT_SET_FEATURE_DEVICE;
}
}
else if (rcp == ENDPOINT_RECIPIENT)
{
uint8_t n = (arg->index & 0x0f);
if (dev_p->configuration == 0)
return USB_UNSUPPORT;
if (dev->configuration == 0)
return -1;
if (arg->len != 0 || (arg->index >> 8) != 0
|| arg->value != 0 || n == ENDP0)
return USB_UNSUPPORT;
|| arg->value != FEATURE_ENDPOINT_HALT || n == ENDP0)
return -1;
if (kl27z_ep_is_disabled (n))
return USB_UNSUPPORT;
return -1;
kl27z_ep_stall (n);
// event??
return USB_SUCCESS;
return USB_EVENT_SET_FEATURE_ENDPOINT;
}
return USB_UNSUPPORT;
return -1;
}
static int
std_set_address (uint8_t req, struct req_args *arg)
std_set_address (struct usb_dev *dev)
{
uint8_t rcp = req & RECIPIENT;
struct device_req *arg = &dev->dev_req;
uint8_t rcp = arg->type & RECIPIENT;
if (USB_SETUP_GET (req))
return USB_UNSUPPORT;
if (USB_SETUP_GET (arg->type))
return -1;
if (rcp == DEVICE_RECIPIENT && arg->len == 0 && arg->value <= 127
&& arg->index == 0 && dev_p->configuration == 0)
return USB_SUCCESS;
&& arg->index == 0 && dev->configuration == 0)
return USB_EVENT_NONE;
return USB_UNSUPPORT;
return -1;
}
static int
std_get_descriptor (uint8_t req, struct req_args *arg)
std_get_descriptor (struct usb_dev *dev)
{
uint8_t rcp = req & RECIPIENT;
struct device_req *arg = &dev->dev_req;
if (USB_SETUP_SET (arg->type))
return -1;
if (USB_SETUP_SET (req))
return USB_UNSUPPORT;
return usb_cb_get_descriptor (rcp, (arg->value >> 8),
(arg->value & 0xff), arg);
return USB_EVENT_GET_DESCRIPTOR;
}
static int
std_get_configuration (uint8_t req, struct req_args *arg)
std_get_configuration (struct usb_dev *dev)
{
uint8_t rcp = req & RECIPIENT;
struct device_req *arg = &dev->dev_req;
uint8_t rcp = arg->type & RECIPIENT;
(void)arg;
if (USB_SETUP_SET (req))
return USB_UNSUPPORT;
if (USB_SETUP_SET (arg->type))
return -1;
if (arg->value != 0 || arg->index != 0 || arg->len != 1)
return -1;
if (rcp == DEVICE_RECIPIENT)
return usb_lld_reply_request (&dev_p->configuration, 1, arg);
return usb_lld_reply_request (dev, &dev->configuration, 1);
return USB_UNSUPPORT;
return -1;
}
static int
std_set_configuration (uint8_t req, struct req_args *arg)
std_set_configuration (struct usb_dev *dev)
{
uint8_t rcp = req & RECIPIENT;
struct device_req *arg = &dev->dev_req;
uint8_t rcp = arg->type & RECIPIENT;
if (USB_SETUP_GET (req))
return USB_UNSUPPORT;
if (USB_SETUP_GET (arg->type))
return -1;
if (rcp == DEVICE_RECIPIENT && arg->index == 0 && arg->len == 0)
return usb_cb_handle_event (USB_EVENT_CONFIG, arg->value);
return USB_EVENT_SET_CONFIGURATION;
return USB_UNSUPPORT;
return -1;
}
static int
std_get_interface (uint8_t req, struct req_args *arg)
std_get_interface (struct usb_dev *dev)
{
uint8_t rcp = req & RECIPIENT;
struct device_req *arg = &dev->dev_req;
uint8_t rcp = arg->type & RECIPIENT;
if (USB_SETUP_SET (req))
return USB_UNSUPPORT;
if (USB_SETUP_SET (arg->type))
return -1;
if (arg->value != 0 || (arg->index >> 8) != 0 || arg->len != 1)
return -1;
if (dev->configuration == 0)
return -1;
if (rcp == INTERFACE_RECIPIENT)
{
if (arg->value != 0 || (arg->index >> 8) != 0 || arg->len != 1)
return USB_UNSUPPORT;
return USB_EVENT_GET_INTERFACE;
if (dev_p->configuration == 0)
return USB_UNSUPPORT;
return usb_cb_interface (USB_GET_INTERFACE, arg);
}
return USB_UNSUPPORT;
return -1;
}
static int
std_set_interface (uint8_t req, struct req_args *arg)
std_set_interface (struct usb_dev *dev)
{
uint8_t rcp = req & RECIPIENT;
struct device_req *arg = &dev->dev_req;
uint8_t rcp = arg->type & RECIPIENT;
if (USB_SETUP_GET (req) || rcp != INTERFACE_RECIPIENT
if (USB_SETUP_GET (arg->type) || rcp != INTERFACE_RECIPIENT
|| arg->len != 0 || (arg->index >> 8) != 0
|| (arg->value >> 8) != 0 || dev_p->configuration == 0)
return USB_UNSUPPORT;
|| (arg->value >> 8) != 0 || dev->configuration == 0)
return -1;
return usb_cb_interface (USB_SET_INTERFACE, arg);
return USB_EVENT_SET_INTERFACE;
}
static void
handle_setup0 (void)
static int
handle_setup0 (struct usb_dev *dev)
{
struct req_args *arg = (struct req_args *)&setup[2];
int r = USB_UNSUPPORT;
struct ctrl_data *data_p = &dev->ctrl_data;
int r = -1;
HANDLER handler;
data_p->addr = NULL;
data_p->len = 0;
data_p->require_zlp = 0;
if ((setup[0] & REQUEST_TYPE) == STANDARD_REQUEST)
if ((dev->dev_req.type & REQUEST_TYPE) == STANDARD_REQUEST)
{
if (setup[1] < TOTAL_REQUEST)
switch (dev->dev_req.request)
{
switch (setup[1])
{
case 0: handler = std_get_status; break;
case 1: handler = std_clear_feature; break;
case 3: handler = std_set_feature; break;
case 5: handler = std_set_address; break;
case 6: handler = std_get_descriptor; break;
case 8: handler = std_get_configuration; break;
case 9: handler = std_set_configuration; break;
case 10: handler = std_get_interface; break;
case 11: handler = std_set_interface; break;
default: handler = std_none; break;
}
r = (*handler) (setup[0], arg);
case 0: handler = std_get_status; break;
case 1: handler = std_clear_feature; break;
case 3: handler = std_set_feature; break;
case 5: handler = std_set_address; break;
case 6: handler = std_get_descriptor; break;
case 8: handler = std_get_configuration; break;
case 9: handler = std_set_configuration; break;
case 10: handler = std_get_interface; break;
case 11: handler = std_set_interface; break;
default: handler = std_none; break;
}
if ((r = (*handler) (dev)) <= 0)
{
/* Handling finished in standard way. */
if (r == 0)
usb_lld_ctrl_good (dev);
else
usb_lld_ctrl_error (dev);
return 0;
}
else
return r;
}
else
r = usb_cb_setup (setup[0], setup[1], arg);
if (r != USB_SUCCESS)
dev_p->state = STALLED;
else if (USB_SETUP_SET (setup[0]))
{
if (arg->len == 0)
{
/* Zero length packet for ACK. */
kl27z_prepare_ep0_in (setup, 0, DATA1);
dev_p->state = WAIT_STATUS_IN;
}
}
return USB_EVENT_CTRL_REQUEST;
}
static void
handle_in0 (uint8_t stat)
static int
handle_in0 (struct usb_dev *dev, uint8_t stat)
{
if (dev_p->state == IN_DATA || dev_p->state == LAST_IN_DATA)
handle_datastage_in (stat);
else if (dev_p->state == WAIT_STATUS_IN)
{ /* Control WRITE transfer done successfully. */
uint16_t value = (setup[3]<<8) | setup[2];
int r = 0;
if ((setup[1] == SET_ADDRESS) &&
((setup[0] & (REQUEST_TYPE | RECIPIENT))
if (dev->state == IN_DATA || dev->state == LAST_IN_DATA)
handle_datastage_in (dev, stat);
else if (dev->state == WAIT_STATUS_IN)
{ /* Control WRITE transfer done successfully. */
uint16_t value = dev->dev_req.value;
if ((dev->dev_req.request == SET_ADDRESS) &&
((dev->dev_req.type & (REQUEST_TYPE | RECIPIENT))
== (STANDARD_REQUEST | DEVICE_RECIPIENT)))
{
kl27z_set_daddr (value);
usb_cb_handle_event (USB_EVENT_ADDRESS, value);
ep[0].rx_odd = 0;
r = USB_EVENT_DEVICE_ADDRESSED;
}
else
usb_cb_ctrl_write_finish (setup[0], setup[1],
(struct req_args *)&setup[2]);
dev_p->state = WAIT_SETUP;
kl27z_prepare_ep0_setup ();
r = USB_EVENT_CTRL_WRITE_FINISH;
dev->state = WAIT_SETUP;
kl27z_prepare_ep0_setup (dev);
}
else
dev_p->state = STALLED;
{
dev->state = STALLED;
kl27z_ep_stall (ENDP0);
}
return r;
}
static void
handle_out0 (uint8_t stat)
handle_out0 (struct usb_dev *dev, uint8_t stat)
{
if (dev_p->state == IN_DATA || dev_p->state == LAST_IN_DATA)
/* Host aborts the control READ transfer before finish. */
dev_p->state = STALLED;
else if (dev_p->state == OUT_DATA)
if (dev->state == OUT_DATA)
/* It's normal control WRITE transfer. */
handle_datastage_out (stat);
else if (dev_p->state == WAIT_STATUS_OUT)
handle_datastage_out (dev, stat);
else if (dev->state == WAIT_STATUS_OUT)
{ /* Control READ transfer done successfully. */
dev_p->state = WAIT_SETUP;
kl27z_prepare_ep0_setup ();
dev->state = WAIT_SETUP;
kl27z_prepare_ep0_setup (dev);
}
else
dev_p->state = STALLED;
{
/*
* dev->state == IN_DATA || dev->state == LAST_IN_DATA
* (Host aborts the transfer before finish)
* Or else, unexpected state.
* STALL the endpoint, until we receive the next SETUP token.
*/
dev->state = STALLED;
kl27z_ep_stall (ENDP0);
}
}
#define USB_TOKEN_ACK 0x02
#define USB_TOKEN_IN 0x09
#define USB_TOKEN_SETUP 0x0d
static void
handle_transaction (uint8_t stat)
static int
handle_transaction (struct usb_dev *dev, uint8_t stat)
{
int odd = (stat >> 2)&1;
uint8_t ep_num = (stat >> 4);
int r;
if (ep_num == 0)
{
@@ -841,33 +826,36 @@ handle_transaction (uint8_t stat)
ep[0].rx_odd ^= 1;
if (TOK_PID (BD_table[odd].ctrl) == USB_TOKEN_SETUP)
{
handle_setup0 ();
r = handle_setup0 (dev);
USB_CTRL1->ISTAT = USB_IS_TOKDNE;
USB_CTRL1->CTL = 0x01; /* Clear TXSUSPENDTOKENBUSY. */
return USB_MAKE_EV (r);
}
else
{
handle_out0 (dev, stat);
USB_CTRL1->ISTAT = USB_IS_TOKDNE;
handle_out0 (stat);
return 0;
}
}
else
{
ep[0].tx_odd ^= 1;
r = handle_in0 (dev, stat);
USB_CTRL1->ISTAT = USB_IS_TOKDNE;
handle_in0 (stat);
return USB_MAKE_EV (r);
}
if (dev_p->state == STALLED)
kl27z_ep_stall (0);
}
else
{
uint16_t len;
if ((stat & 0x08) == 0)
{
dev_p->recv++;
len = (BD_table[4*ep_num+odd].ctrl >> 16)&0x3ff;
ep[ep_num].rx_odd ^= 1;
usb_cb_rx_ready (ep_num);
USB_CTRL1->ISTAT = USB_IS_TOKDNE;
return USB_MAKE_TXRX (ep_num, 0, len);
}
else
{
@@ -878,8 +866,8 @@ handle_transaction (uint8_t stat)
* host: IN ACK
* device: DATA0/1
*
* It is not described in the specification (it's
* ambiguous), but it is actually possible for some host
* Although it is not described in the specification (it's
* ambiguous), it is actually possible for some host
* implementation to send back a NAK on erroneous case like
* a device sent oversized data.
*
@@ -893,39 +881,30 @@ handle_transaction (uint8_t stat)
*/
uint32_t dmaerr = (USB_CTRL1->ERRSTAT & (1 << 5));
int success = (dmaerr == 0);
uint32_t len = (BD_table[4*ep_num+2+odd].ctrl >> 16)&0x3ff;
len = (BD_table[4*ep_num+2+odd].ctrl >> 16)&0x3ff;
if (!success)
{
USB_CTRL1->ERRSTAT = dmaerr; /* Clear error. */
dev_p->error++;
}
USB_CTRL1->ERRSTAT = dmaerr; /* Clear error. */
dev_p->send++;
ep[ep_num].tx_odd ^= 1;
usb_cb_tx_done (ep_num, len);
USB_CTRL1->ISTAT = USB_IS_TOKDNE;
return USB_MAKE_TXRX (ep_num, 1, len);
}
USB_CTRL1->ISTAT = USB_IS_TOKDNE;
}
}
void
usb_lld_reset (uint8_t feature)
usb_lld_reset (struct usb_dev *dev, uint8_t feature)
{
dev_p->feature = feature;
usb_lld_set_configuration (0);
usb_lld_set_configuration (dev, 0);
dev->feature = feature;
dev->state = WAIT_SETUP;
/* Reset USB */
USB_CTRL2->USBTRC0 = 0xc0;
USB_CTRL1->CTL = 0x00; /* Disable USB FS communication module */
dev_p->state = WAIT_SETUP;
dev_p->tkdone = 0;
dev_p->error = 0;
dev_p->stall = 0;
kl27z_set_daddr (0);
kl27z_usb_init ();
@@ -937,13 +916,13 @@ usb_lld_reset (uint8_t feature)
}
void
usb_lld_setup_endp (int n, int rx_en, int tx_en)
usb_lld_setup_endp (struct usb_dev *dev, int n, int rx_en, int tx_en)
{
if (n == 0)
{
/* Enable the endpoint 0. */
USB_ENDPT[0].EP = 0x0d;
kl27z_prepare_ep0_setup ();
kl27z_prepare_ep0_setup (dev);
}
else
{
@@ -968,27 +947,29 @@ usb_lld_setup_endp (int n, int rx_en, int tx_en)
void
usb_lld_set_configuration (uint8_t config)
usb_lld_set_configuration (struct usb_dev *dev, uint8_t config)
{
dev_p->configuration = config;
dev->configuration = config;
}
uint8_t
usb_lld_current_configuration (void)
usb_lld_current_configuration (struct usb_dev *dev)
{
return dev_p->configuration;
return dev->configuration;
}
void
usb_lld_set_data_to_recv (void *p, size_t len)
int
usb_lld_set_data_to_recv (struct usb_dev *dev, void *p, size_t len)
{
struct ctrl_data *data_p = &dev->ctrl_data;
data_p->addr = (uint8_t *)p;
data_p->len = len;
if (len > USB_MAX_PACKET_SIZE)
len = USB_MAX_PACKET_SIZE;
kl27z_prepare_ep0_out (p, len, DATA1);
dev_p->state = OUT_DATA;
dev->state = OUT_DATA;
return 0;
}
/*
@@ -998,9 +979,10 @@ usb_lld_set_data_to_recv (void *p, size_t len)
* BUFLEN: size of the data.
*/
int
usb_lld_reply_request (const void *buf, size_t buflen, struct req_args *a)
usb_lld_reply_request (struct usb_dev *dev, const void *buf, size_t buflen)
{
uint32_t len_asked = a->len;
struct ctrl_data *data_p = &dev->ctrl_data;
uint32_t len_asked = dev->dev_req.len;
uint32_t len;
data_p->addr = (void *)buf;
@@ -1016,12 +998,12 @@ usb_lld_reply_request (const void *buf, size_t buflen, struct req_args *a)
if (data_p->len < USB_MAX_PACKET_SIZE)
{
len = data_p->len;
dev_p->state = LAST_IN_DATA;
dev->state = LAST_IN_DATA;
}
else
{
len = USB_MAX_PACKET_SIZE;
dev_p->state = IN_DATA;
dev->state = IN_DATA;
}
if (len)
@@ -1030,7 +1012,7 @@ usb_lld_reply_request (const void *buf, size_t buflen, struct req_args *a)
data_p->len -= len;
data_p->addr += len;
return USB_SUCCESS;
return 0;
}
void
@@ -1042,12 +1024,6 @@ usb_lld_rx_enable_buf (int n, void *buf, size_t len)
BD_table[4*n+ep[n].rx_odd].buf = buf;
}
int
usb_lld_rx_data_len (int n)
{
return (BD_table[4*n+!ep[n].rx_odd].ctrl >> 16)&0x3ff;
}
void
usb_lld_tx_enable_buf (int n, const void *buf, size_t len)

2
usb_lld.h
View File

@@ -122,7 +122,7 @@ void usb_lld_shutdown (void);
void usb_lld_tx_enable_buf (int ep_num, const void *buf, size_t len);
void usb_lld_rx_enable_buf (int ep_num, void *buf, size_t len);
void usb_lld_setup_endp (int ep_num, int rx_en, int tx_en);
void usb_lld_setup_endp (struct usb_dev *dev, int ep_num, int rx_en, int tx_en);
void usb_lld_stall (int ep_num);
#else
/* EP_TYPE[1:0] EndPoint TYPE */