void dfu_control_setup() {
switch (usb_setup.bRequest) {
case DFU_DNLOAD:
if (dfu_state == DFU_STATE_dfuIDLE || dfu_state == DFU_STATE_dfuDNLOAD_IDLE) {
if (usb_setup.wLength == 0) {
dfu_state = DFU_STATE_dfuMANIFEST_SYNC;
usb_ep0_out();
return usb_ep0_in(0);
} else {
dfu_block_offset = 0;
dfu_cb_dnload_block(usb_setup.wValue, usb_setup.wLength);
if (dfu_state != DFU_STATE_dfuERROR) {
dfu_state = DFU_STATE_dfuDNBUSY;
return usb_ep0_out();
}
}
} else {
dfu_error(DFU_STATUS_errSTALLEDPKT);
}
return usb_ep0_stall();
case DFU_UPLOAD:
dfu_error(DFU_STATUS_errSTALLEDPKT);
return usb_ep0_stall();
case DFU_GETSTATUS: {
if (dfu_state == DFU_STATE_dfuMANIFEST_SYNC) {
dfu_state = DFU_STATE_dfuMANIFEST;
dfu_cb_manifest();
}
uint8_t len = usb_setup.wLength;
if (len > sizeof(DFU_StatusResponse)) len = sizeof(DFU_StatusResponse);
DFU_StatusResponse* status = (DFU_StatusResponse*) ep0_buf_in;
status->bStatus = dfu_status;
status->bwPollTimeout[0] = (dfu_poll_timeout >> 0) & 0xFF;
status->bwPollTimeout[1] = (dfu_poll_timeout >> 8) & 0xFF;
status->bwPollTimeout[2] = (dfu_poll_timeout >> 16) & 0xFF;
status->bState = dfu_state;
status->iString = 0;
usb_ep0_in(len);
return usb_ep0_out();
}
case DFU_ABORT:
case DFU_CLRSTATUS:
dfu_reset();
usb_ep0_in(0);
return usb_ep0_out();
case DFU_GETSTATE:
ep0_buf_in[0] = dfu_state;
usb_ep0_in(1);
return usb_ep0_out();
}
return usb_ep0_stall();
}
static void usb_ep0_standard_device_tx() {
byte strIndex;
byte l1, l2;
switch (ep0_setup_packet.Request) {
case 0: //GET_STATUS
usb_ep0_data_write(usb_device_status, 2);
break;
case 6: //GET_DESCRIPTOR
switch (ep0_setup_packet.wValue2) {
case 1: //Device descriptor
// l1 = *device_descriptor;
// l2 = ep0_setup_packet.wLength1;
// usb_ep0_data_write(device_descriptor,
// l1 < l2 ? l1 : l2);
usb_ep0_data_write(device_descriptor, 18);
break;
case 2: //Configuration descriptor
l1 = *configuration;
l2 = ep0_setup_packet.wLength1;
usb_ep0_data_write(configuration,
l1 < l2 ? l1 : l2);
break;
case 3: //String descriptor
strIndex = ep0_setup_packet.wValue1;
if (strIndex > sizeof(strings)/sizeof(strings[0])) {
return usb_ep0_stall();
} else {
byte *str = strings[strIndex];
l1 = *str;
l2 = ep0_setup_packet.wLength1;
usb_ep0_data_write(str, l1 < l2 ? l1 : l2);
}
break;
default:
return usb_ep0_stall();
}
break;
case 8: //GET_CONFIGURATION
if (usb_state == CONFIGURED) {
strIndex = 1;
} else {
strIndex = 0;
}
usb_ep0_data_write(&strIndex, 1);
break;
default:
return usb_ep0_stall();
}
}
static void usb_ep0_setup() {
ep0_state = WAIT_SETUP;
switch(ep0_setup_packet.Type.Byte) {
case TYPE_STD | RCPT_DEV | DIR_RX:
usb_ep0_standard_device_rx();
break;
case TYPE_STD | RCPT_DEV | DIR_TX:
usb_ep0_standard_device_tx();
break;
case TYPE_STD | RCPT_INT | DIR_RX:
usb_ep0_standard_interface_rx();
break;
case TYPE_STD | RCPT_INT | DIR_TX:
usb_ep0_standard_interface_tx();
break;
case TYPE_STD | RCPT_END | DIR_RX:
usb_ep0_standard_endpoint_rx();
break;
case TYPE_STD | RCPT_END | DIR_TX:
usb_ep0_standard_endpoint_tx();
break;
case TYPE_VEN | RCPT_DEV | DIR_RX:
usb_ep0_vendor_device_rx();
break;
case TYPE_VEN | RCPT_DEV | DIR_TX:
usb_ep0_vendor_device_tx();
break;
default:
usb_ep0_stall();
}
CTL_TSUSPEND = 0;
}
static void usb_ep0_standard_endpoint_tx() {
// switch (ep0_setup_packet.Request) {
// case 0: //GET_STATUS
// break;
// case 12: //SYNCH_FRAME
// break;
// default:
// return usb_ep0_stall(); //STALL
// }
return usb_ep0_stall();
}
static void usb_ep0_standard_endpoint_rx() {
// switch (ep0_setup_packet.Request) {
// case 1: //CLEAR_FEATURE
// break;
// case 3: //SET_FEATURE
// break;
// default:
// return usb_ep0_stall(); //STALL
// }
return usb_ep0_stall();
}
static void usb_ep0_standard_interface_tx() {
// switch (ep0_setup_packet.Request) {
// case 0: //GET_STATUS
// break;
// case 10: //GET_INTERFACE
// break;
// default:
// return usb_ep0_stall(); //STALL
// }
return usb_ep0_stall();
}
static void usb_ep0_out() {
switch (ep0_state) {
case WAIT_SETUP:
return usb_ep0_stall(); //Bad sequence
case DATA_RX:
//All data is <=8 bytes - no more bytes to transfer
// Dont yet support anything that actually uses these bytes.
break;
case DATA_TX:
ep0_state = WAIT_SETUP;
usb_ep0_prep_setup();
}
}
static void usb_ep0_standard_device_rx() {
switch (ep0_setup_packet.Request) {
case 1: //CLEAR_FEATURE
//Ignore this one
break;
case 3: //SET_FEATURE
//Ignore this one
break;
case 5: //SET_ADDRESS
usb_state = ADDR_PENDING;
pending_address = ep0_setup_packet.wValue1;
break;
case 7: //SET_DESCRIPTOR
return usb_ep0_stall(); //Not supported
case 9: //SET_CONFIGURATION
//Lets assume it is picking our ONLY configuration
usb_state = CONFIGURED;
PTAD_PTAD5 = 0;
break;
default:
return usb_ep0_stall();
}
usb_ep0_data_read(0); //Simplify things because we never read > 0
}
void req_info(uint16_t wIndex) {
const char* str = 0;
switch (wIndex) {
case REQ_INFO_GIT_HASH:
str = git_version;
break;
default:
return usb_ep0_stall();
}
uint16_t len = strlen(str);
if (len > USB_EP0_SIZE) len = USB_EP0_SIZE;
memcpy(ep0_buf_in, str, len);
usb_ep0_out();
return usb_ep0_in(len);
}
static void usb_ep0_in() {
if (usb_state == ADDR_PENDING) {
usb_state = ADDRESSED;
ADDR = pending_address;
}
switch (ep0_state) {
case WAIT_SETUP:
return usb_ep0_stall(); //Bad sequence
case DATA_TX:
usb_ep0_fill_in();
break;
case DATA_RX:
ep0_state = WAIT_SETUP;
usb_ep0_prep_setup();
}
}
static void usb_ep0_vendor_device_rx() {
switch (ep0_setup_packet.Request) {
case 0x68: //Reset to bootloader
usb_state = BOOTLOADER;
break;
case 0x70:
PTAD_PTAD5 = 0; //Activate power
break;
case 0x71:
PTAD_PTAD5 = 1; //Disable power
break;
default:
return usb_ep0_stall();
}
usb_ep0_data_read(0);
}
void usb_cb_control_setup(void) {
uint8_t recipient = usb_setup.bmRequestType & USB_REQTYPE_RECIPIENT_MASK;
if (recipient == USB_RECIPIENT_DEVICE) {
switch(usb_setup.bRequest) {
case 0xee:
return usb_handle_msft_compatible(&msft_compatible);
case REQ_INFO: return req_info(usb_setup.wIndex);
case DIGITAL_CONTROL:
return usb_control_req_digital(usb_setup.wIndex, usb_setup.wValue);
case READ_ALL_DIGITAL:
return usb_control_req_digital_read_all();
case ANALOG_SAMPLE:
return usb_control_req_analog_read(usb_setup.wIndex, usb_setup.wValue);
case REQ_BOOT: return req_boot();
}
} else if (recipient == USB_RECIPIENT_INTERFACE) {
}
return usb_ep0_stall();
}
static void usb_ep0_vendor_device_tx() {
return usb_ep0_stall();
}
