331 lines
7.3 KiB
C
331 lines
7.3 KiB
C
#include <stdbool.h>
|
|
#include "cdc_ecm.h"
|
|
#include "contiki.h"
|
|
#include "usb_drv.h"
|
|
#include "usb_descriptors.h"
|
|
#include "usb_specific_request.h"
|
|
#include "rndis/rndis_task.h"
|
|
#include "rndis/rndis_protocol.h"
|
|
#include "uip.h"
|
|
#include "sicslow_ethernet.h"
|
|
#include <stdio.h>
|
|
#if RF230BB
|
|
#include "rf230bb.h"
|
|
#endif
|
|
|
|
#include <avr/pgmspace.h>
|
|
#include <util/delay.h>
|
|
|
|
#define BUF ((struct uip_eth_hdr *)&uip_buf[0])
|
|
#define PRINTF printf
|
|
#define PRINTF_P printf_P
|
|
|
|
extern uint8_t usb_eth_data_buffer[64];
|
|
static U16 usb_ecm_packet_filter = 0;
|
|
|
|
#define PACKET_TYPE_PROMISCUOUS (1<<0)
|
|
#define PACKET_TYPE_ALL_MULTICAST (1<<1)
|
|
#define PACKET_TYPE_DIRECTED (1<<2)
|
|
#define PACKET_TYPE_BROADCAST (1<<3)
|
|
#define PACKET_TYPE_MULTICAST (1<<4)
|
|
|
|
#define Usb_write_word(x) Usb_write_byte((x)&0xFF),Usb_write_byte((x>>8)&0xFF)
|
|
#define Usb_write_long(x) Usb_write_word((x)&0xFFFF),Usb_write_word((x>>16)&0xFFFF)
|
|
|
|
#define Usb_read_word() ((U16)Usb_read_byte()+((U16)Usb_read_byte()<<8))
|
|
|
|
void
|
|
cdc_ecm_set_ethernet_packet_filter(void) {
|
|
usb_ecm_packet_filter = Usb_read_word();
|
|
|
|
Usb_ack_receive_setup();
|
|
Usb_send_control_in();
|
|
usb_endpoint_wait_for_read_control_enabled();
|
|
|
|
PRINTF_P(PSTR("cdc_ecm: Received SET_ETHERNET_PACKET_FILTER: (0x%04X) "),usb_ecm_packet_filter);
|
|
if(usb_ecm_packet_filter & PACKET_TYPE_PROMISCUOUS) {
|
|
PRINTF_P(PSTR("PROMISCUOUS "));
|
|
USB_ETH_HOOK_SET_PROMISCIOUS_MODE(true);
|
|
} else {
|
|
USB_ETH_HOOK_SET_PROMISCIOUS_MODE(false);
|
|
}
|
|
|
|
if(usb_ecm_packet_filter & PACKET_TYPE_ALL_MULTICAST)
|
|
PRINTF_P(PSTR("ALL_MULTICAST "));
|
|
if(usb_ecm_packet_filter & PACKET_TYPE_DIRECTED)
|
|
PRINTF_P(PSTR("DIRECTED "));
|
|
if(usb_ecm_packet_filter & PACKET_TYPE_BROADCAST)
|
|
PRINTF_P(PSTR("BROADCAST "));
|
|
if(usb_ecm_packet_filter & PACKET_TYPE_MULTICAST)
|
|
PRINTF_P(PSTR("MULTICAST "));
|
|
|
|
PRINTF_P(PSTR("\n"));
|
|
}
|
|
|
|
|
|
#define CDC_NOTIFY_NETWORK_CONNECTION (0x00)
|
|
#define CDC_NOTIFY_CONNECTION_SPEED_CHANGE (0x2A)
|
|
|
|
void
|
|
cdc_ecm_notify_network_connection(uint8_t value) {
|
|
#if CDC_ECM_USES_INTERRUPT_ENDPOINT
|
|
Usb_select_endpoint(INT_EP);
|
|
|
|
if(!Is_usb_endpoint_enabled()) {
|
|
//PRINTF_P(PSTR("cdc_ecm: cdc_ecm_notify_network_connection: endpoint not enabled\n"));
|
|
return;
|
|
}
|
|
|
|
if(usb_endpoint_wait_for_IN_ready()!=0) {
|
|
//PRINTF_P(PSTR("cdc_ecm: cdc_ecm_notify_network_connection: Timeout waiting for interrupt endpoint to be available\n"));
|
|
return;
|
|
}
|
|
|
|
Usb_send_control_in();
|
|
|
|
Usb_write_byte(0x51); // 10100001b
|
|
Usb_write_byte(CDC_NOTIFY_NETWORK_CONNECTION);
|
|
Usb_write_byte(value);
|
|
Usb_write_byte(0x00);
|
|
Usb_write_word(ECM_INTERFACE0_NB);
|
|
Usb_write_word(0x0000);
|
|
|
|
Usb_send_in();
|
|
PRINTF_P(PSTR("cdc_ecm: CDC_NOTIFY_NETWORK_CONNECTION %d\n"),value);
|
|
#endif
|
|
}
|
|
|
|
#define CDC_ECM_DATA_ENDPOINT_SIZE 64
|
|
|
|
void cdc_ecm_configure_endpoints() {
|
|
#if CDC_ECM_USES_INTERRUPT_ENDPOINT
|
|
usb_configure_endpoint(INT_EP, \
|
|
TYPE_INTERRUPT, \
|
|
DIRECTION_IN, \
|
|
SIZE_8, \
|
|
TWO_BANKS, \
|
|
NYET_ENABLED);
|
|
#endif
|
|
|
|
usb_configure_endpoint(TX_EP, \
|
|
TYPE_BULK, \
|
|
DIRECTION_IN, \
|
|
SIZE_64, \
|
|
TWO_BANKS, \
|
|
NYET_ENABLED);
|
|
|
|
usb_configure_endpoint(RX_EP, \
|
|
TYPE_BULK, \
|
|
DIRECTION_OUT, \
|
|
SIZE_64, \
|
|
TWO_BANKS, \
|
|
NYET_ENABLED);
|
|
#if CDC_ECM_USES_INTERRUPT_ENDPOINT
|
|
Usb_reset_endpoint(INT_EP);
|
|
#endif
|
|
Usb_reset_endpoint(TX_EP);
|
|
Usb_reset_endpoint(RX_EP);
|
|
usb_eth_is_active = 1;
|
|
}
|
|
|
|
|
|
void
|
|
cdc_ecm_notify_connection_speed_change(uint32_t upstream,uint32_t downstream) {
|
|
#if CDC_ECM_USES_INTERRUPT_ENDPOINT
|
|
Usb_select_endpoint(INT_EP);
|
|
|
|
if(!Is_usb_endpoint_enabled())
|
|
return;
|
|
|
|
if(usb_endpoint_wait_for_IN_ready()!=0)
|
|
return;
|
|
|
|
Usb_send_control_in();
|
|
|
|
Usb_write_byte(0x51); // 10100001b
|
|
Usb_write_byte(CDC_NOTIFY_CONNECTION_SPEED_CHANGE);
|
|
Usb_write_word(0x0000);
|
|
Usb_write_word(ECM_INTERFACE0_NB);
|
|
Usb_write_word(0x0008);
|
|
|
|
Usb_send_in();
|
|
|
|
if(usb_endpoint_wait_for_write_enabled()!=0)
|
|
return;
|
|
|
|
Usb_write_long(upstream);
|
|
Usb_write_long(downstream);
|
|
Usb_send_in();
|
|
|
|
PRINTF_P(PSTR("cdc_ecm: CDC_NOTIFY_CONNECTION_SPEED_CHANGE UP:%d DOWN:%d\n"),upstream,downstream);
|
|
#endif
|
|
}
|
|
|
|
void cdc_ecm_set_active(uint8_t value) {
|
|
if(value!=usb_eth_is_active) {
|
|
Led3_on();
|
|
|
|
usb_eth_is_active = value;
|
|
cdc_ecm_notify_network_connection(value);
|
|
if(value) {
|
|
cdc_ecm_notify_connection_speed_change(250000,250000);
|
|
} else {
|
|
cdc_ecm_notify_connection_speed_change(0,0);
|
|
}
|
|
}
|
|
}
|
|
|
|
uint8_t
|
|
cdc_ecm_process(void) {
|
|
static uint8_t doInit = 1;
|
|
|
|
Usb_select_endpoint(RX_EP);
|
|
|
|
if(!Is_usb_endpoint_enabled()) {
|
|
return 0;
|
|
}
|
|
|
|
if (doInit) {
|
|
#ifdef USB_ETH_HOOK_INIT
|
|
USB_ETH_HOOK_INIT();
|
|
#endif
|
|
cdc_ecm_notify_network_connection(1);
|
|
cdc_ecm_notify_connection_speed_change(250000,250000);
|
|
doInit = 0;
|
|
if(usb_ecm_packet_filter & PACKET_TYPE_PROMISCUOUS) {
|
|
#if RF230BB
|
|
rf230_set_promiscuous_mode(true);
|
|
#else
|
|
radio_set_trx_state(RX_ON);
|
|
#endif
|
|
}
|
|
|
|
// Select again, just to make sure.
|
|
Usb_select_endpoint(RX_EP);
|
|
}
|
|
|
|
if(!usb_eth_is_active) {
|
|
// If we aren't active, just eat the packets.
|
|
if(Is_usb_read_enabled()) {
|
|
Usb_ack_receive_out();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//Connected!
|
|
Led0_on();
|
|
|
|
if(Is_usb_read_enabled()) {
|
|
uint16_t bytecounter;
|
|
uint16_t bytes_received = 0;
|
|
U8 * buffer = uip_buf;
|
|
|
|
if(!usb_eth_ready_for_next_packet()) {
|
|
// Since we aren't ready for a packet yet,
|
|
// just return.
|
|
goto bail;
|
|
}
|
|
|
|
#ifdef USB_ETH_HOOK_RX_START
|
|
USB_ETH_HOOK_RX_START();
|
|
#endif
|
|
|
|
while((bytecounter=Usb_byte_counter_8())==CDC_ECM_DATA_ENDPOINT_SIZE) {
|
|
while((bytes_received<USB_ETH_MTU) && (bytecounter--)) {
|
|
*buffer++ = Usb_read_byte();
|
|
bytes_received++;
|
|
}
|
|
bytes_received+=bytecounter+1;
|
|
|
|
//ACK previous data
|
|
Usb_ack_receive_out();
|
|
|
|
//Wait for new data
|
|
if(usb_endpoint_wait_for_read_enabled()!=0) {
|
|
USB_ETH_HOOK_RX_ERROR("Timeout: read enabled");
|
|
goto bail;
|
|
}
|
|
}
|
|
bytecounter = Usb_byte_counter_8();
|
|
while((bytes_received<USB_ETH_MTU) && (bytecounter--)) {
|
|
*buffer++ = Usb_read_byte();
|
|
bytes_received++;
|
|
}
|
|
bytes_received+=bytecounter+1;
|
|
|
|
//Ack final data packet
|
|
Usb_ack_receive_out();
|
|
|
|
//PRINTF_P(PSTR("cdc_ecm: Got packet %d bytes long\n"),bytes_received);
|
|
|
|
#ifdef USB_ETH_HOOK_RX_END
|
|
USB_ETH_HOOK_RX_END();
|
|
#endif
|
|
|
|
//Send data over RF or to local stack
|
|
if(bytes_received<=USB_ETH_MTU) {
|
|
|
|
USB_ETH_HOOK_HANDLE_INBOUND_PACKET(uip_buf,bytes_received);
|
|
} else {
|
|
USB_ETH_HOOK_RX_ERROR("Oversized packet");
|
|
}
|
|
}
|
|
bail:
|
|
return 1;
|
|
}
|
|
|
|
uint8_t
|
|
ecm_send(uint8_t * senddata, uint16_t sendlen, uint8_t led) {
|
|
U8 byte_in_packet = 0;
|
|
|
|
//Send Data
|
|
Usb_select_endpoint(TX_EP);
|
|
|
|
if(usb_endpoint_wait_for_write_enabled()!=0) {
|
|
USB_ETH_HOOK_TX_ERROR("Timeout: write enabled");
|
|
return 0;
|
|
}
|
|
|
|
#ifdef USB_ETH_HOOK_TX_START
|
|
USB_ETH_HOOK_TX_START();
|
|
#endif
|
|
|
|
//Send packet
|
|
while(sendlen) {
|
|
Usb_write_byte(*senddata);
|
|
senddata++;
|
|
sendlen--;
|
|
byte_in_packet++;
|
|
|
|
//If endpoint is full, send data in
|
|
//And then wait for data to transfer
|
|
if (!Is_usb_write_enabled()) {
|
|
Usb_ack_in_ready();
|
|
|
|
if(usb_endpoint_wait_for_write_enabled()!=0) {
|
|
USB_ETH_HOOK_TX_ERROR("Timeout: write enabled");
|
|
return 0;
|
|
}
|
|
byte_in_packet=0;
|
|
}
|
|
|
|
}
|
|
|
|
//Send last data in - also handles sending a ZLP if needed
|
|
Usb_ack_in_ready();
|
|
|
|
#ifdef USB_ETH_HOOK_TX_END
|
|
USB_ETH_HOOK_TX_END();
|
|
#endif
|
|
|
|
//Wait for ready
|
|
if(usb_endpoint_wait_for_IN_ready()!=0) {
|
|
USB_ETH_HOOK_TX_ERROR("Timeout: IN ready");
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|