#define JUMPER_BIT  5
#define BOOTLED_BIT  6
#define BOOTLED_BITB  7

static inline void  bootLoaderInit(void)
{
	DDRD |= (1 << BOOTLED_BIT);     // turn bootloader led on
	DDRD |= (1 << BOOTLED_BITB);     // turn bootloader led on 2
	PORTD |= (1 << JUMPER_BIT);     /* activate pull-up */
	_delay_us(10);  /* wait for levels to stabilize */
}

static inline void  bootLoaderExit(void)
{
    PORTD = (1 << BOOTLED_BIT);                 // turn bootloader led off
    PORTD = (1 << BOOTLED_BITB);                 // turn bootloader led off
}

...
static void leaveBootloader()
{
 DBG1(0x01, 0, 0);
 bootLoaderExit();
 cli();
...

// - Write to EEPROM
void eepromWrite(unsigned int uiAddress, unsigned char ucData)
{
 /* Wait for completion of previous write */
 while(EECR & (1<<EEPE));
 /* Set up address and Data Registers */
 EEAR = uiAddress;
 EEDR = ucData;
 cli();
 /* Write logical one to EEMPE */
 EECR |= (1<<EEMPE);
 /* Start eeprom write by setting EEPE */
 EECR |= (1<<EEPE);
 sei();
}

// - Read EEPROM
unsigned char eepromRead(unsigned int uiAddress)
{
 /* Wait for completion of previous write */
 while(EECR & (1<<EEPE));
 /* Set up address register */
 EEAR = uiAddress;
 /* Start eeprom read by writing EERE */
 EECR |= (1<<EERE);
 /* Return data from Data Register */
 return EEDR;
}

int main(void)
{
 /* initialize hardware */
 bootLoaderInit();
 odDebugInit();
 DBG1(0x00, 0, 0);

 unsigned char do_boot_load;
 unsigned char do_boot_load_via_eeprom;

 do_boot_load = ~PIND & (1 << JUMPER_BIT);  // see if jumper is set (= 0)
 do_boot_load_via_eeprom = eepromRead(0); // bootloader bit in eeprom address 0

 /* jump to application if jumper is set */
 if(do_boot_load || do_boot_load_via_eeprom){
 eepromWrite(0, 0); // reset bit in eeprom
 PORTD &= ~(1 << BOOTLED_BIT);  /// Light led
 PORTD &= ~(1 << BOOTLED_BITB);  /// Light second led

 uchar i = 0, j = 0;
#ifndef TEST_MODE
 GICR = (1 << IVCE);  /* enable change of interrupt vectors */
 GICR = (1 << IVSEL); /* move interrupts to boot flash section */
#endif
 initForUsbConnectivity();
 do{ /* main event loop */
 wdt_reset();
 usbPoll();
#if BOOTLOADER_CAN_EXIT
 if(exitMainloop){
#if F_CPU == 12800000
 break;  /* memory is tight at 12.8 MHz, save exit delay below */
#endif
 if(--i == 0){
 if(--j == 0)
 break;
 }
 }
#endif
 }while(1);
 }
 leaveBootloader();
 return 0;
}

DEVICE = atmega164p
BOOTLOADER_ADDRESS = 3800
F_CPU = 20000000
FUSEH = 0xd8
FUSEL = 0xff
PROGRAMMER = avrispmkII
PORT = usb
...

make fuse
make flash

#define F_CPU 20000000

#include <avr/io.h>
#include <util/delay.h>

int main(void) {

	// Set Port B pins as all outputs
	DDRB = 0xff;

  while(1) {

    PORTB = 0xFF;
    _delay_ms(100);

    PORTB = 0x00;
    _delay_ms(200);

  }

  return 1;
}

// - Write to EEPROM
void eepromWrite(unsigned int uiAddress, unsigned char ucData) {
  while(EECR & (1<<EEPE));
  EEAR = uiAddress;
  EEDR = ucData;
  cli();
  EECR |= (1<<EEMPE);
  EECR |= (1<<EEPE);
  sei();
}

/* BOOTLOADER  */
void (*jump_to_bootloader)(void) = 0x1C00; __attribute__ ((unused))

void startBootloader(void) {

		eepromWrite(0 , 1);				// stay in bootloader

		TIMSK0 &= ~(1<<TOIE0);			// disable timer overflow

		cli();							// turn off interrupts
		wdt_disable();					// disable watchdog timer
		usbDeviceDisconnect(); 			// disconnect from USB bus

		cbi(ADCSRA, ADIE);				// disable ADC interrupts
		cbi(ADCSRA, ADEN);				// disable ADC (turn off ADC power)

		PORTA = 0;						// pull all pins low
		PORTB = 0;
		PORTC = 0;						

		jump_to_bootloader();
}

// - main
int main(void)
{

	while(1) {

		//jump to bootloader if jumper is HIGH
		if(bit_is_clear(PIND, 5)) {
			startBootloader();
		}
	}
	return 0;
}

// This HidReportDescriptor is not used, it's only here for avoiding a driver popup install on Windows
// See: Vendor type requests sent to custom HID class device
// http://vusb.wikidot.com/usb-device-classes

PROGMEM char usbHidReportDescriptor[33] = {
0x06, 0x00, 0xff,              // USAGE_PAGE (Generic Desktop)
0x09, 0x01,                    // USAGE (Vendor Usage 1)
0xa1, 0x01,                    // COLLECTION (Application)
0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
0x26, 0xff, 0x00,              //   LOGICAL_MAXIMUM (255)
0x75, 0x08,                    //   REPORT_SIZE (8)

0x85, 0x01,                    //   REPORT_ID (1)
0x95, 0x06,                    //   REPORT_COUNT (6)
0x09, 0x00,                    //   USAGE (Undefined)
0xb2, 0x02, 0x01,              //   FEATURE (Data,Var,Abs,Buf)

0x85, 0x02,                    //   REPORT_ID (2)
0x95, 0x83,                    //   REPORT_COUNT (131)
0x09, 0x00,                    //   USAGE (Undefined)
0xb2, 0x02, 0x01,              //   FEATURE (Data,Var,Abs,Buf)
0xc0                           // END_COLLECTION
};

#define USB_CFG_DEVICE_CLASS        0    /* set to 0 if deferred to interface */
#define USB_CFG_DEVICE_SUBCLASS     0
/* See USB specification if you want to conform to an existing device class.
* Class 0xff is "vendor specific".
*/
#define USB_CFG_INTERFACE_CLASS     0x03   /* define class here if not at device level */
#define USB_CFG_INTERFACE_SUBCLASS  0
#define USB_CFG_INTERFACE_PROTOCOL  0
/* See USB specification if you want to conform to an existing device class or
* protocol. The following classes must be set at interface level:
* HID class is 3, no subclass and protocol required (but may be useful!)
* CDC class is 2, use subclass 2 and protocol 1 for ACM
*/
#define USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH    33

main.c

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include "usbdrv.h"
#include "hiddescriptor.h"

import usb

def findDevice(vendor_id):
	buses = usb.busses()
	for bus in buses :
		for device in bus.devices :
			print 'idVendor: %x' % device.idVendor
			if device.idVendor == vendor_id:
				print 'Found'
				return device
	return None

class VUSB:
	USB_VENDOR_ID = 0x16C0
	REQUEST_TYPE = usb.TYPE_VENDOR | usb.RECIP_DEVICE | usb.ENDPOINT_IN

	USB_BUFFER_SIZE = 2
	CMD_ZERO = 0

	def __init__(self):
		device = findDevice(self.USB_VENDOR_ID)
		if not device:
			raise Exception('Device not available')
		self.handle = device.open()

	def getBufferSize(self):
		return self.send_cmd(self.CMD_ZERO)

	def send_cmd(self, cmd, param=0):
		val = self.handle.controlMsg(requestType = self.REQUEST_TYPE, request = cmd, value = param, buffer = self.USB_BUFFER_SIZE)
		return val

def main():
	client = VUSB()
	print client.getBufferSize()

if __name__ == '__main__':
	main()

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <util/delay.h>

#include "usbdrv.h"
#include "hiddescriptor.h"
#include "utils.h"

// - Define
#define DD_MOSI     PINB5
#define DD_SCK      PINB7
#define ADC_PINS 8

// - Global
static uint8_t usb_reply[10];

// - Write to EEPROM
void eepromWrite(unsigned int uiAddress, unsigned char ucData) {
while(EECR & (1<<EEPE));
EEAR = uiAddress;
EEDR = ucData;
cli();
EECR |= (1<<EEMPE);
EECR |= (1<<EEPE);
sei();
}

// - Read EEPROM
unsigned char eepromRead(unsigned int uiAddress) {
while(EECR & (1<<EEPE));
EEAR = uiAddress;
EECR |= (1<<EERE);
return EEDR;
}

// - Bootloader
void (*jump_to_bootloader)(void) = 0x1C00; __attribute__ ((unused))

void startBootloader(void) {
eepromWrite(0 , 1);                // stay in bootloader
TIMSK0 &= ~(1<<TOIE0);            // disable timer overflow
cli();                            // turn off interrupts
wdt_disable();                    // disable watchdog timer
usbDeviceDisconnect();             // disconnect from USB bus
cbi(ADCSRA, ADIE);                // disable ADC interrupts
cbi(ADCSRA, ADEN);                // disable ADC (turn off ADC power)
jump_to_bootloader();
}

// - usbFunctionSetup
USB_PUBLIC uchar usbFunctionSetup(uchar data[8])
{
usbRequest_t    *rq = (void *)data;
static uchar    replyBuf[10];

usbMsgPtr = replyBuf;
if(rq->bRequest == 0) { //POST

replyBuf[0] = usb_reply[0];
replyBuf[1] = usb_reply[1];
replyBuf[2] = usb_reply[2];
replyBuf[3] = usb_reply[3];
replyBuf[4] = usb_reply[4];
replyBuf[5] = usb_reply[5];
replyBuf[6] = usb_reply[6];
replyBuf[7] = usb_reply[7];
replyBuf[8] = usb_reply[8];
replyBuf[9] = usb_reply[9];
return 10;

} else if(rq->bRequest == 1) { //GET
//rq->wIndex.bytes[0];
//rq->wValue.bytes[0];
}
return 0;
}

// - InterruptInit
void InterruptInit() {
PCICR |= (1 << PCIE2);
PCMSK2 |= (1 << PCINT23) | (1 << PCINT22) | (1 << PCINT21) | (1 << PCINT20) | (1 << PCINT19) | (1 << PCINT18) | (1 << PCINT17) | (1 << PCINT16);
}

// - InterruptTrigged
SIGNAL (SIG_PIN_CHANGE2)
{
//CODE
}

// - SPI_MasterInit
void SPI_MasterInit(void)
{
/* Set MOSI and SCK output, all others input */
DDRB = (1<<DD_MOSI)|(1<<DD_SCK);

/* Enable SPI, Master, set clock rate fck/16 */
SPCR = (1<<SPE)|(1<<MSTR);
SPSR = (1<<SPI2X);
}

// - SPI_MasterTransmit
void SPI_MasterTransmit(char cData)
{
/* Start transmission */
SPDR = cData;
/* Wait for transmission complete */
while(!(SPSR & (1<<SPIF)))
;
}

// - ADC_setPint
void ADC_setPin (int8_t pin) {
pin %= ADC_PINS;
pin   |= ADMUX & -8;
ADMUX  = pin;
}

// - hardwareInit
static void hardwareInit(void)
{
//USB

uchar i, j;

/* activate pull-ups except on USB lines */
USB_CFG_IOPORT = (uchar) ~ ((1 << USB_CFG_DMINUS_BIT) | (1 << USB_CFG_DPLUS_BIT));

/* all pins input except USB (-> USB reset) */
#ifdef USB_CFG_PULLUP_IOPORT    /* use usbDeviceConnect()/usbDeviceDisconnect() if available */
USBDDR = 0;        /* we do RESET by deactivating pullup */
usbDeviceDisconnect();
#else
USBDDR = (1 << USB_CFG_DMINUS_BIT) | (1 << USB_CFG_DPLUS_BIT);
#endif

j = 0;
while (--j) {        /* USB Reset by device only required on Watchdog Reset */
i = 0;
while (--i);    /* delay >10ms for USB reset */
}

#ifdef USB_CFG_PULLUP_IOPORT
usbDeviceConnect();
#else
USBDDR = 0;        /*  remove USB reset condition */
#endif

// ADC SETUP :: FREE RUNNING MODE

// PRESCALER 64
ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (0 << ADPS0);
// AUTO TRIGGER ENABLE
ADCSRA |= (1 << ADATE);
// AVCC with external capacitor at AREF pin
ADMUX |= (0 << REFS1) | (1 << REFS0);
// RIGHT ADJUST
ADMUX |= (0 << ADLAR);
// CHANNEL 0
ADMUX |= (0 << MUX4) | (0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (0 << MUX0);
// FREE RUNNING MODE
ADCSRB |= (0 << ADTS2) | (0 << ADTS1) | (0 << ADTS0);
// ENABLE ADC
ADCSRA |= (1 << ADEN);

// PORT A: INPUT
DDRA = 0x00;
PORTA = 0x00;

// PORT B: OUTPUT
DDRB = 0xFF;

// PORT C: INPUT
DDRC = 0x00;

//POWER LED
DDRD |= (1 << 6);
PORTD &= ~(1 << 6);

//SPI init
SPI_MasterInit();

//Interrupt init
InterruptInit();
}

// - Main
int main(void)
{
wdt_enable(WDTO_1S);
hardwareInit();
usbInit();
sei();

ADCSRA |= (1 << ADSC); //Start Free Running Mode

while(1) {
wdt_reset();
usbPoll();

//BOOTLOADER
if(bit_is_clear(PIND, 5)) {
startBootloader();
}

//SPI CODE
SPI_MasterTransmit('A');

//YOUR CODE

//USB TEST
usb_reply[0] = 1;
usb_reply[1] = 2;
usb_reply[2] = 3;
usb_reply[3] = 4;
usb_reply[4] = 5;
usb_reply[5] = 6;
usb_reply[6] = 7;
usb_reply[7] = 8;
usb_reply[8] = 0;
usb_reply[9] = 0;

}
return 0;
}