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> 2016-06-08 NIIBE Yutaka <gniibe@fsij.org>
* mcu/usb-stm32f103.c: Rewrite to be event driven API. * 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-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*) * example-cdc/tty.h: Change tty API to be C string (char*)
friendly. friendly.
* example-fs-bb48/tty.h: Ditto.
2016-06-02 Niibe Yutaka <gniibe@fsij.org> 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 static void
put_line (struct tty *tty, const char *line) 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 = static const char *help_string =
@@ -203,7 +203,7 @@ cmd_mdw (struct tty *tty, const char *line)
*s++ = '\r'; *s++ = '\r';
*s++ = '\n'; *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 = compose_hex (string, v);
*s++ = '\r'; *s++ = '\r';
*s++ = '\n'; *s++ = '\n';
tty_send (tty, (uint8_t *)string, sizeof (string)); tty_send (tty, string, sizeof (string));
} }
#endif #endif
@@ -369,7 +369,7 @@ cmd_adc (struct tty *tty, const char *line)
{ {
*s++ = '\r'; *s++ = '\r';
*s++ = '\n'; *s++ = '\n';
tty_send (tty, (uint8_t *)output, s - output); tty_send (tty, output, s - output);
s = output; s = output;
if (i >= 64) if (i >= 64)
break; break;
@@ -393,14 +393,14 @@ cmd_sysinfo (struct tty *tty, const char *line)
*s++ = sys_version[6]; *s++ = sys_version[6];
*s++ = '\r'; *s++ = '\r';
*s++ = '\n'; *s++ = '\n';
tty_send (tty, (uint8_t *)output, s - output); tty_send (tty, output, s - output);
memcpy (output, "Board ID: ", 10); memcpy (output, "Board ID: ", 10);
s = output + 10; s = output + 10;
s = compose_hex (s, sys_board_id); s = compose_hex (s, sys_board_id);
*s++ = '\r'; *s++ = '\r';
*s++ = '\n'; *s++ = '\n';
tty_send (tty, (uint8_t *)output, s - output); tty_send (tty, output, s - output);
memcpy (output, "Board name: ", 12); memcpy (output, "Board name: ", 12);
s = output + 12; s = output + 12;
@@ -412,7 +412,7 @@ cmd_sysinfo (struct tty *tty, const char *line)
*s++ = '\r'; *s++ = '\r';
*s++ = '\n'; *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); (*command_table[i].handler) (tty, p);
else else
{ {
uint8_t crlf[] = { '\r', '\n' }; char crlf[] = { '\r', '\n' };
put_line (tty, "No such command: "); 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)); 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; m = 50;
while (1) while (1)
{ {
uint8_t s[LINEBUFSIZE]; char s[LINEBUFSIZE];
connection_loop: connection_loop:
u = 1; u = 1;
@@ -175,7 +175,7 @@ main (int argc, const char *argv[])
uint32_t usec; uint32_t usec;
/* Prompt */ /* Prompt */
if (tty_send (tty, (uint8_t *)"> ", 2) < 0) if (tty_send (tty, "> ", 2) < 0)
break; break;
usec = 3000000; /* 3.0 seconds */ usec = 3000000; /* 3.0 seconds */

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

@@ -5,5 +5,5 @@ struct tty;
struct tty *tty_open (void); struct tty *tty_open (void);
void tty_wait_configured (struct tty *tty); void tty_wait_configured (struct tty *tty);
void tty_wait_connection (struct tty *tty); void tty_wait_connection (struct tty *tty);
int tty_send (struct tty *tty, const uint8_t *buf, int count); int tty_send (struct tty *tty, const char *buf, int count);
int tty_recv (struct tty *tty, uint8_t *buf, uint32_t *timeout); 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 * In that case, add argument to TTY_OPEN function and
* modify TTY_GET function to get the TTY structure. Functions which * 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. * should be modified, too.
* *
* Modification of TTY_MAIN thread will be also needed to echo back * 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 #define NUM_INTERFACES 2
void static void
usb_cb_device_reset (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 */ /* Initialize Endpoint 0 */
usb_lld_setup_endp (ENDP0, 1, 1); usb_lld_setup_endp (dev, ENDP0, 1, 1);
chopstx_mutex_lock (&tty0.mtx); chopstx_mutex_lock (&tty0.mtx);
tty0.inputline_len = 0; tty0.inputline_len = 0;
@@ -253,13 +253,15 @@ usb_cb_device_reset (void)
#define CDC_CTRL_DTR 0x0001 #define CDC_CTRL_DTR 0x0001
void static void
usb_cb_ctrl_write_finish (uint8_t req, uint8_t req_no, struct req_args *arg) 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 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); 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 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); struct tty *t = tty_get (arg->index, 0);
if (req_no == USB_CDC_REQ_GET_LINE_CODING) if (arg->request == USB_CDC_REQ_GET_LINE_CODING)
return usb_lld_reply_request (&t->line_coding, return usb_lld_reply_request (dev, &t->line_coding,
sizeof (struct line_coding), arg); sizeof (struct line_coding));
} }
else /* USB_SETUP_SET (req) */ 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)) && arg->len == sizeof (struct line_coding))
{ {
struct tty *t = tty_get (arg->index, 0); struct tty *t = tty_get (arg->index, 0);
usb_lld_set_data_to_recv (&t->line_coding, return usb_lld_set_data_to_recv (dev, &t->line_coding,
sizeof (struct line_coding)); sizeof (struct line_coding));
return USB_SUCCESS;
} }
else if (req_no == USB_CDC_REQ_SET_CONTROL_LINE_STATE) else if (arg->request == USB_CDC_REQ_SET_CONTROL_LINE_STATE)
return USB_SUCCESS; return 0;
} }
return USB_UNSUPPORT; return -1;
} }
int static int
usb_cb_setup (uint8_t req, uint8_t req_no, struct req_args *arg) 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) 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 static int
usb_cb_get_descriptor (uint8_t rcp, uint8_t desc_type, uint8_t desc_index, usb_get_descriptor (struct usb_dev *dev)
struct req_args *arg)
{ {
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) if (rcp != DEVICE_RECIPIENT)
return USB_UNSUPPORT; return -1;
if (desc_type == DEVICE_DESCRIPTOR) if (desc_type == DEVICE_DESCRIPTOR)
return usb_lld_reply_request (vcom_device_desc, sizeof (vcom_device_desc), return usb_lld_reply_request (dev,
arg); vcom_device_desc, sizeof (vcom_device_desc));
else if (desc_type == CONFIG_DESCRIPTOR) else if (desc_type == CONFIG_DESCRIPTOR)
return usb_lld_reply_request (vcom_config_desc, sizeof (vcom_config_desc), return usb_lld_reply_request (dev,
arg); vcom_config_desc, sizeof (vcom_config_desc));
else if (desc_type == STRING_DESCRIPTOR) else if (desc_type == STRING_DESCRIPTOR)
{ {
const uint8_t *str; 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); size = sizeof (vcom_string3);
break; break;
default: 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 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 (interface == 0)
{ {
if (!stop) if (!stop)
usb_lld_setup_endp (ENDP2, 0, 1); usb_lld_setup_endp (dev, ENDP2, 0, 1);
else else
usb_lld_stall (ENDP2); usb_lld_stall (ENDP2);
} }
@@ -373,8 +382,8 @@ vcom_setup_endpoints_for_interface (uint16_t interface, int stop)
{ {
if (!stop) if (!stop)
{ {
usb_lld_setup_endp (ENDP1, 0, 1); usb_lld_setup_endp (dev, ENDP1, 0, 1);
usb_lld_setup_endp (ENDP3, 1, 0); usb_lld_setup_endp (dev, ENDP3, 1, 0);
/* Start with no data receiving (ENDP3 not enabled)*/ /* Start with no data receiving (ENDP3 not enabled)*/
} }
else else
@@ -385,85 +394,86 @@ vcom_setup_endpoints_for_interface (uint16_t interface, int stop)
} }
} }
int static int
usb_cb_handle_event (uint8_t event_type, uint16_t value) usb_set_configuration (struct usb_dev *dev)
{ {
int i; int i;
uint8_t current_conf; 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); chopstx_mutex_lock (&tty0.mtx);
tty0.device_state = ADDRESSED; tty0.device_state = ADDRESSED;
chopstx_cond_signal (&tty0.cnd);
chopstx_mutex_unlock (&tty0.mtx); 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 static int
usb_cb_interface (uint8_t cmd, struct req_args *arg) usb_set_interface (struct usb_dev *dev)
{ {
const uint8_t zero = 0; uint16_t interface = dev->dev_req.index;
uint16_t interface = arg->index; uint16_t alt = dev->dev_req.value;
uint16_t alt = arg->value;
if (interface >= NUM_INTERFACES) if (interface >= NUM_INTERFACES)
return USB_UNSUPPORT; return -1;
switch (cmd) if (alt != 0)
return -1;
else
{ {
case USB_SET_INTERFACE: vcom_setup_endpoints_for_interface (dev, interface, 0);
if (alt != 0) return 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;
} }
} }
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. * 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); put_char_to_ringbuffer (t, c);
} }
void static void
usb_cb_tx_done (uint8_t ep_num, uint32_t len) usb_tx_done (uint8_t ep_num, uint16_t len)
{ {
struct tty *t = tty_get (-1, ep_num); struct tty *t = tty_get (-1, ep_num);
@@ -594,17 +604,16 @@ tty_input_char (struct tty *t, int c)
return r; return r;
} }
void static void
usb_cb_rx_ready (uint8_t ep_num) usb_rx_ready (uint8_t ep_num, uint16_t len)
{ {
struct tty *t = tty_get (-1, ep_num); struct tty *t = tty_get (-1, ep_num);
if (ep_num == ENDP3) if (ep_num == ENDP3)
{ {
int i, r; int i;
r = usb_lld_rx_data_len (ENDP3); for (i = 0; i < len; i++)
for (i = 0; i < r; i++)
if (tty_input_char (t, t->recv_buf0[i])) if (tty_input_char (t, t->recv_buf0[i]))
break; break;
@@ -646,6 +655,8 @@ static void *
tty_main (void *arg) tty_main (void *arg)
{ {
struct tty *t = arg; struct tty *t = arg;
struct usb_dev dev;
int e;
#if defined(OLDER_SYS_H) #if defined(OLDER_SYS_H)
/* /*
@@ -654,9 +665,9 @@ tty_main (void *arg)
* *
* When USB interrupt occurs between usb_lld_init (which assumes * When USB interrupt occurs between usb_lld_init (which assumes
* ISR) and chopstx_claim_irq (which clears pending interrupt), * 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 * interrupts, thus, we call it unconditionally here, just in case
* if there is a request. * if there is a request.
* *
@@ -665,19 +676,117 @@ tty_main (void *arg)
* chopstx_claim_irq after usb_lld_init overrides that. * 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); chopstx_claim_irq (&usb_intr, INTR_REQ_USB);
usb_interrupt_handler (); goto event_handle;
#else #else
chopstx_claim_irq (&usb_intr, INTR_REQ_USB); chopstx_claim_irq (&usb_intr, INTR_REQ_USB);
usb_lld_init (VCOM_FEATURE_BUS_POWERED); usb_lld_init (&dev, VCOM_FEATURE_BUS_POWERED);
#endif #endif
while (1) while (1)
{ {
chopstx_poll (NULL, 1, &usb_intr); chopstx_poll (NULL, 1, &usb_intr);
if (usb_intr.ready) 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); chopstx_mutex_lock (&t->mtx);
if (t->device_state == CONFIGURED && t->flag_connected if (t->device_state == CONFIGURED && t->flag_connected
@@ -720,8 +829,7 @@ tty_wait_connection (struct tty *t)
t->flag_input_avail = 0; t->flag_input_avail = 0;
t->send_head = t->send_tail = 0; t->send_head = t->send_tail = 0;
t->inputline_len = 0; t->inputline_len = 0;
/* Accept input for line */ usb_lld_rx_enable_buf (ENDP3, t->recv_buf0, 64); /* Accept input for line */
usb_lld_rx_enable_buf (ENDP3, t->recv_buf0, 64);
chopstx_mutex_unlock (&t->mtx); chopstx_mutex_unlock (&t->mtx);
} }
@@ -738,10 +846,10 @@ check_tx (struct tty *t)
} }
int int
tty_send (struct tty *t, const uint8_t *buf, int len) tty_send (struct tty *t, const char *buf, int len)
{ {
int r; int r;
const uint8_t *p; const char *p;
int count; int count;
p = buf; p = buf;
@@ -800,7 +908,7 @@ check_rx (void *arg)
* *
*/ */
int int
tty_recv (struct tty *t, uint8_t *buf, uint32_t *timeout) tty_recv (struct tty *t, char *buf, uint32_t *timeout)
{ {
int r; int r;
chopstx_poll_cond_t poll_desc; chopstx_poll_cond_t poll_desc;

546
mcu/usb-mkl27z.c
View File

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