Retcode
usb_install_keyboard_driver(Environ *e, Package *pkg, USB_self *usb,
usb_device_descriptor_t *dev, usb_config_descriptor_t *cfg,
usb_interface_descriptor_t *ifc)
{
Retcode ret;
Byte name[STR_SIZE];
DPRINTF(("usb_install_keyboard_driver: addr=%d interface=%d\n",
usb->addr, usb->interface));
ret = prop_set_str(pkg->props, "device_type", CSTR, "keyboard", CSTR);
if (ret == NO_ERROR)
ret = init_entries(e, pkg->dict, usb_kbd_methods);
/* make keyboard aliases if none already exist */
if (ret == NO_ERROR)
(void)get_device_name(e, pkg, name);
if (ret == NO_ERROR &&
find_table(e->aliases->props, "keyboard", CSTR) == NULL)
ret = make_devalias(e, "keyboard", CSTR, name, CSTR);
if (ret == NO_ERROR &&
find_table(e->aliases->props, "usbkeyboard", CSTR) == NULL)
ret = make_devalias(e, "usbkeyboard", CSTR, name, CSTR);
/* set config descriptor 0 to turn on keyboard */
ret = usb_setup(e, usb, usb->addr, USB_CONTROL_ENDPOINT,
UT_WRITE_DEVICE, UR_SET_CONFIG,
0, cfg->configuration_value, 0, 0, NULL);
/* set keyboard to boot protocol (0) */
if (ret == NO_ERROR)
ret = usb_setup(e, usb, usb->addr, USB_CONTROL_ENDPOINT,
UT_WRITE_CLASS_INTERFACE, UR_SET_PROTOCOL,
0, 0, usb->interface, 0, NULL);
if (ret == NO_ERROR)
ret = usb_setup(e, usb, usb->addr, USB_CONTROL_ENDPOINT,
UT_WRITE_CLASS_INTERFACE, UR_SET_IDLE,
0, 0, usb->interface, 0, NULL);
return ret;
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(usb_serial_process, ev, data)
{
PROCESS_BEGIN();
set_serial_number();
usb_setup();
usb_cdc_acm_setup();
usb_set_global_event_process(&usb_serial_process);
usb_cdc_acm_set_event_process(&usb_serial_process);
usb_set_ep_event_process(EPIN, &usb_serial_process);
usb_set_ep_event_process(EPOUT, &usb_serial_process);
while(1) {
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_EXIT) {
break;
}
if(ev == PROCESS_EVENT_POLL) {
do_work();
}
}
PROCESS_END();
}
int main(void)
{
clock_setup();
gpio_setup();
tim_setup();
spi_setup();
dac_setup();
dma_setup();
usb_setup();
/* Attach the device to USB. */
syscfg_enable_usb_pullup();
/* Clear interrupt. */
usbdevfs_clear_interrupt(USBDEVFS_ALL_INTERRUPT);
/* Enable interrupt. */
usbdevfs_enable_interrupt(USBDEVFS_CORRECT_TRANSFER | USBDEVFS_ERROR |
USBDEVFS_RESET | USBDEVFS_SOF);
/* Wait forever and do nothing. */
while (1)
__asm__ ("nop");
return 0;
}
void setup_usb(void)
{
uip_ipaddr_t hostaddr, netmask, defrouter;
uip_ipaddr(&hostaddr, 10,0,0,2);
uip_ipaddr(&netmask, 255,0,0,0);
uip_ipaddr(&defrouter, 10,0,0,1);
uip_sethostaddr(&hostaddr);
uip_setnetmask(&netmask);
uip_setdraddr(&defrouter);
/*
uip_over_mesh_set_net(&hostaddr, &netmask);
uip_fw_register(&slipif);
uip_over_mesh_set_gateway_netif(&slipif);
uip_fw_default(&meshif);
uip_over_mesh_init(UIP_OVER_MESH_CHANNEL);
*/
printf("uIP started with IP address %d.%d.%d.%d\n",
uip_ipaddr_to_quad(&hostaddr));
#ifdef WITH_USB
printf("Setting up USB\n");
usb_setup();
printf("usb setup done\n");
usb_cdc_eth_set_ifaddr(&hostaddr);
usb_cdc_eth_setup();
#endif
printf("cdc_eth setup done\n");
}
void system_setup(void)
{
clock_setup();
mco_setup();
usb_setup();
systick_setup();
rng_setup();
battery_setup();
speaker_setup();
jack_setup();
// setup pad and screen
interface_setup();
// setup and reset SAM2695
sam2695_setup();
wait_ms(100);
sam2695_reset();
usbmidi_setup();
// init gfx and fill screen
gfx_init(ssd1306_drawpixel, SSD1306_WIDTH, SSD1306_HEIGHT, GFX_FONT_SMALL);
gfx_setRotation(GFX_ROT_180);
gfx_fillScreen(OLED_BLACK);
gfx_setTextColor(OLED_WHITE, OLED_BLACK);
// gfx_setTextWrap(1);
gfx_setTextSize(1);
ssd1306_display();
}
Retcode
usb_set_leds(Environ *e, USB_self *usb, uByte lock)
{
return usb_setup(e, usb, usb->addr, USB_CONTROL_ENDPOINT,
UT_WRITE_CLASS_INTERFACE, UR_SET_REPORT,
UHID_OUTPUT_REPORT, 0, usb->interface,
1, &lock);
}
void usbtest_usb_setup(void)
{
usb_setup(&config);
printf("appending interfaces\n");
usb_append_interface_lowspeed(if_descriptor_lowspeed, sizeof(if_descriptor_lowspeed));
usb_append_interface_highspeed(if_descriptor_lowspeed, sizeof(if_descriptor_lowspeed));
usbc_setup_endpoint(1, USB_OUT, 64, USB_BULK);
usbc_setup_endpoint(1, USB_IN, 64, USB_BULK);
}
void acm_start()
{
task_init(&acm_parse_task, "ACM");
usb_setup(acm_enumerate, acm_started);
usb_install_ep_handler(ACM_EP_SEND, USBIn, acm_sent, 0);
usb_install_ep_handler(ACM_EP_RECV, USBOut, acm_received, 0);
usb_install_setup_handler(acm_setup);
}
static void startUSB()
{
usb_setup();
usb_install_ep_handler(4, USBOut, controlReceived, 0);
usb_install_ep_handler(2, USBOut, dataReceived, 0);
usb_install_ep_handler(3, USBIn, controlSent, 0);
usb_install_ep_handler(1, USBIn, dataSent, 0);
usb_start(enumerateHandler, startHandler);
}
// Initialize hardware devices
void
device_hardware_setup(void)
{
usb_setup();
ps2port_setup();
block_setup();
lpt_setup();
serial_setup();
cbfs_payload_setup();
}
void acm_start()
{
task_init(&acm_parse_task, "ACM", TASK_DEFAULT_STACK_SIZE);
usb_setup(acm_enumerate, acm_started);
usb_install_ep_handler(ACM_EP_SEND, USBIn, acm_sent, 0);
usb_install_ep_handler(ACM_EP_RECV, USBOut, acm_received, 0);
usb_install_setup_handler(acm_setup);
acm_prev_printf_handler = addPrintfHandler(acm_buffer_notify);
}
void target_usb_setup(void)
{
usb_setup(&config);
append_usb_interfaces();
usb_add_string("LK", 1);
usb_add_string("LK Industries", 2);
usb_start();
}
static
void
do_other_wait(void)
{
int rv;
struct setup setup;
byte configuration[18];
do {
sleep_poll();
delay(1000);
// get the configuration descriptor
usb_setup(1, SETUP_TYPE_STANDARD, SETUP_RECIP_DEVICE, REQUEST_GET_DESCRIPTOR, (CONFIGURATION_DESCRIPTOR<<8)|0, 0, sizeof(configuration), &setup);
rv = usb_control_transfer(&setup, configuration, sizeof(configuration));
} while (rv > 0);
}
// Initialize hardware devices
static void
init_hw(void)
{
usb_setup();
ps2port_setup();
lpt_setup();
serial_setup();
floppy_setup();
ata_setup();
ahci_setup();
cbfs_payload_setup();
ramdisk_setup();
virtio_blk_setup();
virtio_scsi_setup();
lsi_scsi_setup();
}
void configure_system() {
kill_interrupts(); // turn off interrupts just in case
turn_analog_inputs_off(); // kill those pesky analogue inputs
#ifdef USB_SERIAL_DEBUG
serial_setup(BRGH_HIGH_SPEED, SPBRG_57600);
#endif
usb_cdc_setup();
usb_setup();
turn_usb_ints_on();
turn_peripheral_ints_on();
turn_global_ints_on();
}
int main(void)
{
cm_disable_interrupts();
clk_tree_setup();
mco_setup();
clock_setup();
usb_setup();
cli_setup();
pwm_init();
led_setup();
button_setup();
ncn_setup();
cm_enable_interrupts();
while (1) {
__WFI();
}
return 0;
}
// Initialize hardware devices
void
device_hardware_setup(void)
{
usb_setup();
ps2port_setup();
lpt_setup();
serial_setup();
floppy_setup();
ata_setup();
ahci_setup();
cbfs_payload_setup();
ramdisk_setup();
virtio_blk_setup();
virtio_scsi_setup();
lsi_scsi_setup();
esp_scsi_setup();
megasas_setup();
pvscsi_setup();
}
void setup() {
Serial.begin(115200);
Notify(PSTR("initializing WiFi\n"));
wifi_init();
Notify(PSTR("waiting for connection\n"));
wifi_connect();
Notify(PSTR("setting up USB\n"));
usb_setup();
hokuyo_data = (char*) malloc(HOKUYO_DATA_LENGTH);
if (hokuyo_data) {
Notify(PSTR("hokuyo_data allocated\n"));
}
hokuyo_on();
Notify(PSTR("hokuyo on\n"));
Wire.begin(I2C_MASTER_ADDRESS);
Wire.onReceive(receive);
}
static int setup_devices() {
// Basic prerequisites for everything else
miu_setup();
power_setup();
clock_setup();
// Need interrupts for everything afterwards
interrupt_setup();
gpio_setup();
// For scheduling/sleeping niceties
timer_setup();
event_setup();
// Other devices
usb_shutdown();
uart_setup();
dma_setup();
usb_setup();
return 0;
}
static void handle_data(void){
#ifdef USE_STTERM
unsigned char tmp_c;
#endif
uint32_t tmp=0;
char crc=0;
#ifdef USE_STTERM
if(stlinky_rx_ready()){
scanf("%c", &tmp_c);
INPUT[k] = tmp_c;
gpio_toggle(GPIOD, GPIO15);
#else
if(usart_has_data()){
INPUT[k] = usart_read();
#endif
k++;
if(k==1 && INPUT[0]!=0x53){ // 'S'
#ifdef DEBUG
printf("ERROR AT START-BYTE %d\r\n",INPUT[0]);
#endif
k=0;
}
if(k==10 && INPUT[9]!=0x45){ // 'E'
#ifdef DEBUG
printf("ERROR AT END-BYTE %d\r\n",INPUT[8]);
#endif
k=0;
}
if(k==11){
#ifdef DEBUG
printf("Package: ");
for(tmp=0;tmp<10;tmp++) printf("%d ",INPUT[tmp]);
printf("\n");
#endif
for(tmp=0;tmp<8;tmp++) KEYS[tmp] = INPUT[tmp+1];
crc = getCRC(KEYS,8);
if(crc==INPUT[10]){
#ifdef DEBUG
printf("INPUT OK!\r\n");
#endif
if(usb_ready == 3) usb_send_packet(KEYS, 8);
}else{
#ifdef DEBUG
printf("ERROR AT CRC-BYTE %d vs %d\r\n",INPUT[10],crc);
#endif
}
k=0;
}
}
}
void tim3_isr(void){
if(timer_get_flag(TIM3, TIM_SR_UIF)){
handle_data();
timer_clear_flag(TIM3, TIM_SR_UIF);
}
}
void tim4_isr(void){
if(timer_get_flag(TIM4, TIM_SR_UIF)){
if(usb_ready==3){
gpio_toggle(GPIOD,GPIO14);
KEYS[0]=0;
KEYS[1]=0;
KEYS[3]=0;
KEYS[4]=0;
KEYS[5]=0;
KEYS[6]=0;
KEYS[7]=0;
KEYS[2]=0x04;
usb_send_packet(KEYS, 8);
KEYS[2]=0x00;
usb_send_packet(KEYS, 8);
KEYS[2]=0x05;
usb_send_packet(KEYS, 8);
KEYS[2]=0x00;
usb_send_packet(KEYS, 8);
}
timer_clear_flag(TIM4, TIM_SR_UIF);
}
}
void tim5_isr(void){
if(timer_get_flag(TIM5, TIM_SR_UIF)){
gpio_toggle(GPIOD, GPIO15);
timer_clear_flag(TIM5, TIM_SR_UIF);
}
}
int main(void) {
iwdg_reset();
iwdg_set_period_ms(5);
iwdg_start();
rcc_clock_setup_hse_3v3(&hse_8mhz_3v3[CLOCK_3V3_168MHZ]);
rcc_periph_clock_enable(RCC_GPIOD);
systick_setup();
gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO12 | GPIO13 | GPIO14 | GPIO15);
gpio_clear(GPIOD, GPIO12 | GPIO13 | GPIO14 | GPIO15);
iwdg_set_period_ms(500);
iwdg_reset();
msleep(400);
iwdg_set_period_ms(5);
iwdg_reset();
gpio_set(GPIOD, GPIO15);
// msleep(100000); /* SLEEEEEEEEEEEEEEEEEEEEEEP */
#ifdef USE_STTERM
stlinky_init();
#else
usart_setup();
#endif
timer2_setup(100);
usb_setup();
//timer4_setup(1);
timer3_setup(100);
timer5_setup(2);
// gpio_set(GPIOD, GPIO12 | GPIO13 | GPIO14 | GPIO15);
while(1) {
iwdg_reset();
}
return 0;
}
// ----------------------------------------------------------------------
// Inspect an incoming packet.
// ----------------------------------------------------------------------
static void usb_receive ( byte_t* data, byte_t rx_len )
{
byte_t len;
byte_t type;
byte_t limit;
usb_tx_state = TX_STATE_RAM;
len = 0;
if ( usb_rx_token == USB_PID_SETUP )
{
limit = data[6];
if ( data[7] )
{
limit = 255;
}
type = data[0] & 0x60;
if ( type == 0x00 )
{ // Standard request
if ( data[1] == 0 ) // GET_STATUS
{
len = 2;
#if USBTINY_MAX_POWER == 0
data[0] = (data[0] == 0x80);
#else
data[0] = 0;
#endif
data[1] = 0;
}
else if ( data[1] == 5 ) // SET_ADDRESS
{
new_address = data[2];
}
else if ( data[1] == 6 ) // GET_DESCRIPTOR
{
usb_tx_state = TX_STATE_ROM;
if ( data[3] == 1 )
{ // DEVICE
data = (byte_t*) &descr_device;
len = sizeof(descr_device);
}
else if ( data[3] == 2 )
{ // CONFIGURATION
data = (byte_t*) &descr_config;
len = sizeof(descr_config);
// If we got this far, there's a good chance everything is OK with enumeration so turn on the OK led
PORTD = _BV(5);
}
#if VENDOR_NAME_ID || DEVICE_NAME_ID || SERIAL_ID
else if ( data[3] == 3 )
{ // STRING
if ( data[2] == 0 )
{
data = (byte_t*) &string_langid;
len = sizeof(string_langid);
}
#if VENDOR_NAME_ID
else if ( data[2] == VENDOR_NAME_ID )
{
data = (byte_t*) &string_vendor;
len = sizeof(string_vendor);
}
#endif
#if DEVICE_NAME_ID
else if ( data[2] == DEVICE_NAME_ID )
{
data = (byte_t*) &string_device;
len = sizeof(string_device);
}
#endif
#if SERIAL_ID
else if ( data[2] == SERIAL_ID )
{
data = (byte_t*) &string_serial;
len = sizeof(string_serial);
}
#endif
}
#endif
}
else if ( data[1] == 8 ) // GET_CONFIGURATION
{
data[0] = 1; // return bConfigurationValue
len = 1;
}
else if ( data[1] == 10 ) // GET_INTERFACE
{
data[0] = 0;
len = 1;
}
}
else
{ // Class or Vendor request
len = usb_setup( data );
#if USBTINY_CALLBACK_IN
if ( len == 0xff )
{
usb_tx_state = TX_STATE_CALLBACK;
}
#endif
}
if ( len > limit )
{
len = limit;
}
usb_tx_data = data;
}
#if USBTINY_CALLBACK_OUT
else if ( rx_len > 0 )
{ // usb_rx_token == USB_PID_OUT
usb_out( data, rx_len );
}
#endif
usb_tx_total = len;
usb_tx_buf[0] = USB_PID_DATA0; // next data packet will be DATA1
}
PROCESS_THREAD(gateway_process, ev , data)
{
static struct etimer timer;
PROCESS_BEGIN();
usb_set_user_process(process_current);
usb_setup();
usb_cdc_acm_setup();
uip_fw_default(&slipif);
uip_over_mesh_set_gateway_netif(&slipif);
process_start(&slip_process, NULL);
set_gateway();
while(ev != PROCESS_EVENT_EXIT) {
PROCESS_WAIT_EVENT();
if (ev == PROCESS_EVENT_TIMER) {
leds_toggle(LEDS_YELLOW);
/* printf("FIFOP: %d\n", FIFOP_IS_1); */
etimer_restart(&timer);
} else if (ev == PROCESS_EVENT_MSG) {
const struct usb_user_msg * const msg = data;
switch(msg->type) {
case USB_USER_MSG_TYPE_CONFIG:
printf("User config\n");
if (msg->data.config != 0) {
usb_setup_bulk_endpoint(DEV_TO_HOST,
input_buffer, sizeof(input_buffer));
usb_setup_bulk_endpoint(HOST_TO_DEV,
output_buffer, sizeof(output_buffer));
usb_setup_interrupt_endpoint(0x83,interrupt_buffer,
sizeof(interrupt_buffer));
etimer_set(&timer, CLOCK_SECOND);
} else {
etimer_stop(&timer);
usb_disable_endpoint(DEV_TO_HOST);
usb_disable_endpoint(HOST_TO_DEV);
usb_disable_endpoint(0x83);
}
break;
case USB_USER_MSG_TYPE_EP_OUT(2):
{
/*unsigned int len = msg->data.length;
printf("Received %d:\n", len); */
{
unsigned char ch;
unsigned int xfer;
while((xfer = usb_recv_data(HOST_TO_DEV, &ch, 1)) > 0) {
/* printf(" %02x",ch); */
if (slip_input_byte(ch)) break;
}
/* printf("\n"); */
}
}
break;
}
}
}
printf("USB test process exited\n");
PROCESS_END();
}
PROCESS_THREAD(usb_eth_process, ev , data)
{
PROCESS_BEGIN();
usb_register_request_handler(&cdc_eth_request_hook);
usb_setup();
usb_set_ep_event_process(DATA_OUT, process_current);
usb_set_global_event_process(process_current);
uip_fw_default(&usbethif);
uip_setethaddr(default_uip_ethaddr);
uip_arp_init();
while(1) {
PROCESS_WAIT_EVENT();
if (ev == PROCESS_EVENT_EXIT) break;
if (ev == PROCESS_EVENT_POLL) {
unsigned int events = usb_get_global_events();
if (events) {
if (events & USB_EVENT_CONFIG) {
if (usb_get_current_configuration() != 0) {
printf("Configured\n");
usb_setup_bulk_endpoint(DATA_IN);
usb_setup_bulk_endpoint(DATA_OUT);
usb_setup_interrupt_endpoint(INTERRUPT_IN);
init_recv_buffer();
usb_submit_recv_buffer(DATA_OUT, &recv_buffer);
#if 0
{
static const uint8_t foo[4] = {0x12,0x34,0x56,0x78};
xmit_buffer[0].next = NULL;
xmit_buffer[0].left = sizeof(foo);
xmit_buffer[0].flags = USB_BUFFER_SHORT_END;
xmit_buffer[0].data = &foo;
usb_submit_xmit_buffer(DATA_IN, &xmit_buffer[0]);
}
#endif
} else {
usb_disable_endpoint(DATA_IN);
usb_disable_endpoint(DATA_OUT);
usb_disable_endpoint(INTERRUPT_IN);
}
}
}
events = usb_get_ep_events(DATA_OUT);
if (events & USB_EP_EVENT_NOTIFICATION) {
uip_len = sizeof(recv_data) - recv_buffer.left;
/* printf("Received: %d bytes\n", uip_len); */
memcpy(uip_buf, recv_data, uip_len);
#if UIP_CONF_IPV6
if(BUF->type == uip_htons(UIP_ETHTYPE_IPV6)) {
uip_neighbor_add(&IPBUF->srcipaddr, &BUF->src);
tcpip_input();
} else
#endif /* UIP_CONF_IPV6 */
if(BUF->type == uip_htons(UIP_ETHTYPE_IP)) {
uip_len -= sizeof(struct uip_eth_hdr);
tcpip_input();
} else if(BUF->type == uip_htons(UIP_ETHTYPE_ARP)) {
uip_arp_arpin();
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if (uip_len > 0) {
memcpy(xmit_data, uip_buf, uip_len);
xmit_buffer[0].next = NULL;
xmit_buffer[0].data = xmit_data;
xmit_buffer[0].left = uip_len;
xmit_buffer[0].flags = USB_BUFFER_SHORT_END;
usb_submit_xmit_buffer(DATA_IN, &xmit_buffer[0]);
/* printf("Sent: %d bytes\n", uip_len); */
}
}
init_recv_buffer();
usb_submit_recv_buffer(DATA_OUT, &recv_buffer);
}
}
}
PROCESS_END();
}
void cdcacm_target_init(void)
{
rcc_clock_setup_hsi(&rcc_hsi_8mhz[RCC_CLOCK_48MHZ]);
usb_setup();
}
PROCESS_THREAD(eriks_process, ev , data)
{
static struct etimer timer;
uip_ipaddr_t myaddr;
uip_ipaddr_t hostaddr;
uip_ipaddr_t netmask;
#if 0
struct dhcps_client_lease dhleases[3];
struct dhcps_config dhconfig;
#endif
PROCESS_BEGIN();
printf("Eriks super process\n\r");
uip_init();
#if 0
dhconfig.leases = &dhleases[0];
dhconfig.num_leases = 3;
dhconfig.default_lease_time = 3600;
uip_ipaddr(&dhconfig.netmask, 255,255,255,255);
uip_ipaddr(&dhconfig.dnsaddr, 1,2,3,4);
uip_ipaddr(&dhconfig.dnsaddr, 1,0,0,1);
dhconfig.flags = DHCP_CONF_NETMASK | DHCP_CONF_DEFAULT_ROUTER;
#endif
/* usb_set_user_process(process_current); */
uip_ipaddr(&myaddr, 10,0,0,2);
uip_sethostaddr(&hostaddr);
uip_ipaddr(&netmask, 255,0,0,0);
uip_sethostaddr(&hostaddr);
uip_ipaddr(&myaddr, 10,0,0,1);
uip_ipaddr(&netmask, 255,255,0,0);
usb_setup();
#if 0
usb_cdc_eth_set_ifaddr(&myaddr);
usb_cdc_eth_setup();
dhcps_init(&dhconfig);
while(ev != PROCESS_EVENT_EXIT) {
PROCESS_WAIT_EVENT();
printf("EVENT\n\r");
}
#else
usb_cdc_acm_setup();
while(ev != PROCESS_EVENT_EXIT) {
PROCESS_WAIT_EVENT();
if (ev == PROCESS_EVENT_TIMER) {
leds_toggle(LEDS_YELLOW);
/* printf("FIFOP: %d\n", FIFOP_IS_1); */
etimer_restart(&timer);
} else if (ev == PROCESS_EVENT_MSG) {
const struct usb_user_msg * const msg = data;
switch(msg->type) {
case USB_USER_MSG_TYPE_CONFIG:
printf("User config\n");
if (msg->data.config != 0) {
#if 0
usb_setup_bulk_endpoint(DEV_TO_HOST,
input_buffer, sizeof(input_buffer));
usb_setup_bulk_endpoint(HOST_TO_DEV,
output_buffer, sizeof(output_buffer));
usb_setup_interrupt_endpoint(0x83,interrupt_buffer,
sizeof(interrupt_buffer));
etimer_set(&timer, CLOCK_SECOND);
#endif
} else {
#if 0
etimer_stop(&timer);
usb_disable_endpoint(DEV_TO_HOST);
usb_disable_endpoint(HOST_TO_DEV);
usb_disable_endpoint(0x83);
#endif
}
break;
case USB_USER_MSG_TYPE_EP_OUT(2):
{
#if 0
/*unsigned int len = msg->data.length;
printf("Received %d:\n", len); */
{
unsigned char ch;
unsigned int xfer;
/*
while((xfer = usb_recv_data(HOST_TO_DEV, &ch, 1)) > 0) {
printf(" %02x",ch);
*/
/* if (slip_input_byte(ch)) break; */
}
#endif
/* printf("\n"); */
}
break;
}
}
}
#endif
printf("Exiting USB process\n\r");
PROCESS_END();
}
// ----------------------------------------------------------------------
// Inspect an incoming packet.
// ----------------------------------------------------------------------
static void usb_receive ( byte_t* data, byte_t rx_len )
{
byte_t len;
byte_t type;
txlen_t limit;
usb_tx_state = TX_STATE_RAM;
len = 0;
limit = 0;
if ( usb_rx_token == USB_PID_SETUP )
{
#if USBTINY_CALLBACK_IN == 2
limit = * (uint_t*) & data[6];
#else
limit = data[6];
if ( data[7] )
{
limit = 255;
}
#endif
type = data[0] & 0x60;
if ( type == 0x00 )
{ // Standard request
if ( data[1] == 0 ) // GET_STATUS
{
len = 2;
#if USBTINY_MAX_POWER == 0
data[0] = (data[0] == 0x80);
#else
data[0] = 0;
#endif
data[1] = 0;
}
else if ( data[1] == 5 ) // SET_ADDRESS
{
usb_new_address = data[2];
#ifdef USBTINY_USB_OK_LED
SET(USBTINY_USB_OK_LED);// LED on
#endif
}
else if ( data[1] == 6 ) // GET_DESCRIPTOR
{
usb_tx_state = TX_STATE_ROM;
if ( data[3] == 1 )
{ // DEVICE
data = (byte_t*) &descr_device;
len = sizeof(descr_device);
}
else if ( data[3] == 2 )
{ // CONFIGURATION
data = (byte_t*) &descr_config;
len = sizeof(descr_config);
}
#if VENDOR_NAME_ID || DEVICE_NAME_ID || SERIAL_ID
else if ( data[3] == 3 )
{ // STRING
if ( data[2] == 0 )
{
data = (byte_t*) &string_langid;
len = sizeof(string_langid);
}
#if VENDOR_NAME_ID
else if ( data[2] == VENDOR_NAME_ID )
{
data = (byte_t*) &string_vendor;
len = sizeof(string_vendor);
}
#endif
#if DEVICE_NAME_ID
else if ( data[2] == DEVICE_NAME_ID )
{
data = (byte_t*) &string_device;
len = sizeof(string_device);
}
#endif
#if SERIAL_ID
else if ( data[2] == SERIAL_ID )
{
data = (byte_t*) &string_serial;
len = sizeof(string_serial);
}
#endif
}
#endif
}
else if ( data[1] == 8 ) // GET_CONFIGURATION
{
data[0] = 1; // return bConfigurationValue
len = 1;
}
else if ( data[1] == 10 ) // GET_INTERFACE
{
data[0] = 0;
len = 1;
}
}
else
{ // Class or Vendor request
len = usb_setup( data );
#if USBTINY_CALLBACK_IN
if ( len == 0xff )
{
usb_tx_state = TX_STATE_CALLBACK;
}
#endif
}
if ( len < limit
#if USBTINY_CALLBACK_IN == 2
&& len != 0xff
#endif
)
{
limit = len;
}
usb_tx_data = data;
}
#if USBTINY_CALLBACK_OUT
else if ( rx_len > 0 )
{ // usb_rx_token == USB_PID_OUT
usb_out( data, rx_len );
}
#endif
usb_tx_total = limit;
usb_tx_buf[0] = USB_PID_DATA0; // next data packet will be DATA1
}
static void usb_control(uint32_t stat)
{
bdt_t *b;
uint32_t pid, size;
uint8_t *buf;
const uint8_t *data;
b = stat2bufferdescriptor(stat);
pid = BDT_PID(b->desc);
//count = b->desc >> 16;
buf = b->addr;
//serial_print("pid:");
//serial_phex(pid);
//serial_print(", count:");
//serial_phex(count);
//serial_print("\n");
switch (pid) {
case 0x0D: // Setup received from host
//serial_print("PID=Setup\n");
//if (count != 8) ; // panic?
// grab the 8 byte setup info
setup.word1 = *(uint32_t *)(buf);
setup.word2 = *(uint32_t *)(buf + 4);
// give the buffer back
b->desc = BDT_DESC(EP0_SIZE, DATA1);
//table[index(0, RX, EVEN)].desc = BDT_DESC(EP0_SIZE, 1);
//table[index(0, RX, ODD)].desc = BDT_DESC(EP0_SIZE, 1);
// clear any leftover pending IN transactions
ep0_tx_ptr = NULL;
if (ep0_tx_data_toggle) {
}
//if (table[index(0, TX, EVEN)].desc & 0x80) {
//serial_print("leftover tx even\n");
//}
//if (table[index(0, TX, ODD)].desc & 0x80) {
//serial_print("leftover tx odd\n");
//}
table[index(0, TX, EVEN)].desc = 0;
table[index(0, TX, ODD)].desc = 0;
// first IN after Setup is always DATA1
ep0_tx_data_toggle = 1;
#if 0
serial_print("bmRequestType:");
serial_phex(setup.bmRequestType);
serial_print(", bRequest:");
serial_phex(setup.bRequest);
serial_print(", wValue:");
serial_phex16(setup.wValue);
serial_print(", wIndex:");
serial_phex16(setup.wIndex);
serial_print(", len:");
serial_phex16(setup.wLength);
serial_print("\n");
#endif
// actually "do" the setup request
usb_setup();
// unfreeze the USB, now that we're ready
USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit
break;
case 0x01: // OUT transaction received from host
case 0x02:
//serial_print("PID=OUT\n");
#ifdef CDC_STATUS_INTERFACE
if (setup.wRequestAndType == 0x2021 /*CDC_SET_LINE_CODING*/) {
int i;
uint8_t *dst = usb_cdc_line_coding;
//serial_print("set line coding ");
for (i=0; i<7; i++) {
//serial_phex(*buf);
*dst++ = *buf++;
}
//serial_phex32(*(uint32_t *)usb_cdc_line_coding);
//serial_print("\n");
if (*(uint32_t *)usb_cdc_line_coding == 134) usb_reboot_timer = 15;
endpoint0_transmit(NULL, 0);
}
#endif
#ifdef KEYBOARD_INTERFACE
if (setup.word1 == 0x02000921 && setup.word2 == ((1<<16)|KEYBOARD_INTERFACE)) {
keyboard_leds = buf[0];
endpoint0_transmit(NULL, 0);
}
#endif
#ifdef SEREMU_INTERFACE
if (setup.word1 == 0x03000921 && setup.word2 == ((4<<16)|SEREMU_INTERFACE)
&& buf[0] == 0xA9 && buf[1] == 0x45 && buf[2] == 0xC2 && buf[3] == 0x6B) {
usb_reboot_timer = 5;
endpoint0_transmit(NULL, 0);
}
#endif
// give the buffer back
b->desc = BDT_DESC(EP0_SIZE, DATA1);
break;
case 0x09: // IN transaction completed to host
//serial_print("PID=IN:");
//serial_phex(stat);
//serial_print("\n");
// send remaining data, if any...
data = ep0_tx_ptr;
if (data) {
size = ep0_tx_len;
if (size > EP0_SIZE) size = EP0_SIZE;
endpoint0_transmit(data, size);
data += size;
ep0_tx_len -= size;
ep0_tx_ptr = (ep0_tx_len > 0 || size == EP0_SIZE) ? data : NULL;
}
if (setup.bRequest == 5 && setup.bmRequestType == 0) {
setup.bRequest = 0;
//serial_print("set address: ");
//serial_phex16(setup.wValue);
//serial_print("\n");
USB0_ADDR = setup.wValue;
}
break;
//default:
//serial_print("PID=unknown:");
//serial_phex(pid);
//serial_print("\n");
}
USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit
}
static void startUSB()
{
usb_setup(enumerateHandler, startHandler);
}
