avrdude-5.4.diff

This is a software implementation of the USB low-speed protocol for the Atmel ATtiny microcontrolle

+	struct	usb_bus*	bus;
+	struct	usb_device*	dev = 0;
+
+	usb_init();
+	usb_find_busses();
+	usb_find_devices();
+	for	( bus = usb_busses; bus; bus = bus->next )
+	{
+		for	( dev = bus->devices; dev; dev = dev->next )
+		{
+			if	(  dev->descriptor.idVendor == USBTINY_VENDOR
+				&& dev->descriptor.idProduct == USBTINY_PRODUCT
+				)
+			{
+				usb_handle = usb_open( dev );
+				if	( ! usb_handle )
+				{
+					fprintf( stderr,
+						"Cannot open USB device: %s\n",
+						usb_strerror() );
+					return -1;
+				}
+				return 0;
+			}
+		}
+	}
+	fprintf( stderr, "Could not find USB device 0x%x/0x%x\n",
+		USBTINY_VENDOR, USBTINY_PRODUCT );
+	return -1;
+}
+
+static	void	usbtiny_close ( PROGRAMMER* pgm )
+{
+	if	( ! usb_handle )
+	{
+		return;
+	}
+	usb_close( usb_handle );
+	usb_handle = NULL;
+}
+
+static	void	usbtiny_set_chunk_size ( int period )
+{
+	chunk_size = CHUNK_SIZE;
+	while	( chunk_size > 8 && period > 16 )
+	{	// Reduce the chunk size for a slow SCK to reduce
+		// the maximum time of a single USB transfer.
+		chunk_size >>= 1;
+		period >>= 1;
+	}
+}
+
+static	int	usbtiny_set_sck_period ( PROGRAMMER* pgm, double v )
+{
+	sck_period = (int) (v * 1e6 + 0.5);
+	if	( sck_period < SCK_MIN )
+	{
+		sck_period = SCK_MIN;
+	}
+	if	( sck_period > SCK_MAX )
+	{
+		sck_period = SCK_MAX;
+	}
+	printf( "%s: Setting SCK period to %d usec\n", progname, sck_period );
+	usb_control( USBTINY_POWERUP, sck_period, RESET_LOW );
+	usbtiny_set_chunk_size( sck_period );
+	return 0;
+}
+
+static	int	usbtiny_initialize ( PROGRAMMER* pgm, AVRPART* p )
+{
+	byte_t	res[4];
+
+	if	( pgm->bitclock > 0.0 )
+	{	// -B option specified: convert to valid range for sck_period
+		usbtiny_set_sck_period( pgm, pgm->bitclock );
+	}
+	else
+	{	// -B option not specified: use default
+		sck_period = SCK_DEFAULT;
+		if	( verbose )
+		{
+			printf( "%s: Using SCK period of %d usec\n",
+				progname, sck_period );
+		}
+		usb_control( USBTINY_POWERUP, sck_period, RESET_LOW );
+		usbtiny_set_chunk_size( sck_period );
+	}
+	usleep( 50000 );
+	if	( ! usbtiny_avr_op( pgm, p, AVR_OP_PGM_ENABLE, res ) )
+	{	// no response, RESET and try again
+		usb_control( USBTINY_POWERUP, sck_period, RESET_HIGH );
+		usb_control( USBTINY_POWERUP, sck_period, RESET_LOW );
+		usleep( 50000 );
+		if	( ! usbtiny_avr_op( pgm, p, AVR_OP_PGM_ENABLE, res ) )
+		{	// give up
+			return -1;
+		}
+	}
+	return 0;
+}
+
+static	void	usbtiny_powerdown ( PROGRAMMER* pgm )
+{
+	if	( ! usb_handle )
+	{
+		return;
+	}
+	usb_control( USBTINY_POWERDOWN, 0, 0 );
+}
+
+static	int	usbtiny_cmd ( PROGRAMMER* pgm, byte_t cmd[4], byte_t res[4] )
+{
+	int	r;
+
+	memset( res, '\0', sizeof(res) );
+	r = usb_in( USBTINY_SPI, (cmd[1] << 8) | cmd[0], (cmd[3] << 8) | cmd[2],
+	            res, sizeof(res), 8 * sck_period );
+	if	( verbose > 1 )
+	{
+		printf( "CMD: [%02x %02x %02x %02x] [%02x %02x %02x %02x]\n",
+		        cmd[0], cmd[1], cmd[2], cmd[3],
+			res[0], res[1], res[2], res[3] );
+	}
+	return (r == 0 && res[2] == cmd[1]);
+}
+
+static	int	usbtiny_chip_erase ( PROGRAMMER* pgm, AVRPART* p )
+{
+	byte_t	res[4];
+	int	r;
+
+	r = usbtiny_avr_op( pgm, p, AVR_OP_CHIP_ERASE, res );
+	usleep( p->chip_erase_delay );
+	usb_control( USBTINY_POWERUP, sck_period, RESET_HIGH );
+	pgm->initialize( pgm, p );
+	return r;
+}
+
+static	void	usbtiny_display ( PROGRAMMER* pgm, const char* p )
+{
+}
+
+static	void	usbtiny_enable ( PROGRAMMER* pgm )
+{
+}
+
+static	void	usbtiny_disable ( PROGRAMMER* pgm )
+{
+}
+
+static	int	usbtiny_paged_load ( PROGRAMMER* pgm, AVRPART* p, AVRMEM* m,
+		                     int page_size, int n_bytes )
+{
+	int	i;
+	int	chunk;
+	int	req;
+
+	req = ( strcmp( m->desc, "flash" ) == 0
+	      ? USBTINY_FLASH_READ
+	      : USBTINY_EEPROM_READ
+	      );
+	for	( i = 0; i < n_bytes; i += chunk )
+	{
+		chunk = chunk_size;
+		if	( chunk > n_bytes - i )
+		{
+			chunk = n_bytes - i;
+		}
+		usb_in( req, 0, i, m->buf + i, chunk, 32 * sck_period );
+		report_progress( i + chunk, n_bytes, NULL );
+	}
+	return n_bytes;
+}
+
+static	int	usbtiny_paged_write ( PROGRAMMER* pgm, AVRPART* p, AVRMEM* m,
+		                      int page_size, int n_bytes )
+{
+	int	i;
+	int	chunk;
+	int	next;
+	int	req;
+	int	delay;
+
+	req = ( strcmp( m->desc, "flash" ) == 0
+	      ? USBTINY_FLASH_WRITE
+	      : USBTINY_EEPROM_WRITE
+	      );
+	delay = 0;
+	if	( ! m->paged )
+	{
+		i = (m->readback[1] << 8) | m->readback[0];
+		usb_control( USBTINY_POLL_BYTES, i, 0 );
+		delay = m->max_write_delay;
+	}
+	for	( i = 0; i < n_bytes; i = next )
+	{
+		chunk = chunk_size;
+		if	( m->paged && chunk > page_size )
+		{
+			chunk = page_size;
+		}
+		if	( chunk > n_bytes - i )
+		{
+			chunk = n_bytes - i;
+		}
+		usb_out( req, delay, i, m->buf + i, chunk, 32 * sck_period + delay );
+		next = i + chunk;
+		if	(  m->paged
+			&& ((next % page_size) == 0 || next == n_bytes)
+			)
+		{
+			avr_write_page( pgm, p, m, (unsigned long) i );
+		}
+		report_progress( next, n_bytes, NULL );
+	}
+	return n_bytes;
+}
+
+
+extern	void	usbtiny_initpgm ( PROGRAMMER* pgm )
+{
+	strcpy( pgm->type, "USBTINY" );
+	pgm->initialize		= usbtiny_initialize;
+	pgm->display		= usbtiny_display;
+	pgm->enable		= usbtiny_enable;
+	pgm->disable		= usbtiny_disable;
+	pgm->powerup		= NULL;
+	pgm->powerdown		= usbtiny_powerdown;
+	pgm->program_enable	= NULL;
+	pgm->chip_erase		= usbtiny_chip_erase;
+	pgm->cmd		= usbtiny_cmd;
+	pgm->open		= usbtiny_open;
+	pgm->close		= usbtiny_close;
+	pgm->paged_load		= usbtiny_paged_load;
+	pgm->paged_write	= usbtiny_paged_write;
+	pgm->read_byte		= avr_read_byte_default;
+	pgm->write_byte		= avr_write_byte_default;
+	pgm->set_sck_period	= usbtiny_set_sck_period;
+}
diff -pu /dev/null avrdude-5.4/usbtiny.h
--- /dev/null	2007-11-20 19:44:18.000000000 +0100
+++ avrdude-5.4/usbtiny.h	2008-01-15 14:08:59.000000000 +0100
@@ -0,0 +1 @@
+extern	void	usbtiny_initpgm ( PROGRAMMER* pgm );