WebSVN – public – Blame – /sportwatcher/branches/sportwatcher-0.4/libgarmin/usb_comm.c

Rev	Author	Line No.	Line
93	andreas	1	`#include "config.h"`
		2	`#include <stdio.h>`
101	andreas	3	`#include <stdlib.h>`
		4	`#include <errno.h>`
93	andreas	5	`#include <string.h>`
		6	`#include <ctype.h>`
101	andreas	7	`#include <unistd.h>`
		8	`#include <sys/stat.h>`
		9	`#include <fcntl.h>`
		10	`#include <sys/select.h>`
		11	`#include <sys/signal.h>`
		12	`#include <time.h>`
93	andreas	13	`#include <usb.h>`
		14	`#include "garmin.h"`
		15
101	andreas	16	`/* #if defined (HAVE_SYS_TERMIOS_H)`
		17	`#include <sys/termios.h>`
		18	`#else`
		19	`#if defined (HAVE_TERMIOS_H) */`
		20	`#include <termios.h>`
		21	`/* #endif`
		22	`#endif`
		23	`*/`
93	andreas	24	`#define INTR_TIMEOUT 3000`
		25	`#define BULK_TIMEOUT 3000`
		26
101	andreas	27	`#ifndef TRUE`
		28	`#define TRUE 1`
		29	`#endif`
93	andreas	30
101	andreas	31	`#ifndef FALSE`
		32	`#define FALSE 0`
		33	`#endif`
		34
		35	`/* something magic about 64, garmin driver will not return more than`
		36	`* 64 at a time. If you read less than 64 bytes the next read will`
		37	`* just get the last of the 64 byte buffer.`
		38	`*/`
		39	`#define ASYNC_DATA_SIZE 64`
		40	`#define PRIV_PKTID_SET_MODE 2`
		41	`#define PRIV_PKTID_INFO_RESP 4`
		42	`#define PRIV_PKTID_INFO_REQ 3`
		43	`#define GARMIN_LAYERID_PRIVATE 0x01106E4B`
		44
		45	`const char *USBdevice = NULL;`
		46	`int method = 0; /* 0 = Read directly from USB-Device, 1 = read from special device */`
		47	`struct termios ttyset, ttyset_old;`
		48	`static fd_set all_fds;`
		49	`void signal_handler_IO (int status); /* definition of signal handler */`
		50	`int wait_flag = TRUE; /* TRUE while no signal received */`
		51
		52	`int garmin_set_speed(garmin_unit *garmin, unsigned int speed, unsigned int stopbits);`
		53
		54	`void garmin_set_device(const char *device)`
		55	`{`
		56	`USBdevice = device;`
		57	`}`
		58
		59	`void garmin_set_method(int mth)`
		60	`{`
		61	`method = (mth != 0) ? 1 : 0;`
		62	`}`
		63
93	andreas	64	`/* Close the USB connection with the Garmin device. */`
		65
101	andreas	66	`int garmin_close(garmin_unit *garmin)`
93	andreas	67	`{`
101	andreas	68	`if (method && garmin->usb.fd != -1)`
		69	`{`
		70	`if (isatty(garmin->usb.fd))`
		71	`{`
		72	`/* force hangup on close on systems that don't do HUPCL properly */`
		73	`cfsetispeed(&ttyset, (speed_t)B0);`
		74	`cfsetospeed(&ttyset, (speed_t)B0);`
		75	`tcsetattr(garmin->usb.fd, TCSANOW, &ttyset);`
		76	`}`
93	andreas	77
101	andreas	78	`/* this is the clean way to do it */`
		79	`ttyset_old.c_cflag \|= HUPCL;`
		80	`tcsetattr(garmin->usb.fd, TCSANOW, &ttyset_old);`
		81	`close(garmin->usb.fd);`
		82	`garmin->usb.fd = -1;`
		83	`USBdevice = NULL;`
		84	`}`
		85	`else if (garmin->usb.handle != NULL )`
		86	`{`
		87	`usb_release_interface(garmin->usb.handle,0);`
		88	`usb_close(garmin->usb.handle);`
		89	`garmin->usb.handle = NULL;`
		90	`}`
		91
		92	`return 0;`
93	andreas	93	`}`
		94
		95	`/*`
		96	`Open the USB connection with the first Garmin device we find. Eventually,`
		97	`I'd like to add the ability to select a particular device.`
		98	`*/`
		99
101	andreas	100	`int garmin_open(garmin_unit *garmin)`
93	andreas	101	`{`
101	andreas	102	`struct usb_bus * bi;`
		103	`struct usb_device * di;`
		104	`int i;`
		105	`static unsigned int rates[] = {0, 4800, 9600, 19200, 38400, 57600};`
		106	`garmin_packet p;`
		107	`struct sigaction saio;`
136	andreas	108	`char hv0[1024];`
93	andreas	109
101	andreas	110	`if (method && garmin->usb.fd == -1)`
		111	`{`
		112	`/* check for USB serial drivers -- very Linux-specific */`
		113	`if (access("/sys/module/garmin_gps", R_OK) != 0)`
		114	`{`
136	andreas	115	`garmin_queue_error("garmin_gps not active!", err_error);`
101	andreas	116	`return 0;`
		117	`}`
93	andreas	118
101	andreas	119	`if ((garmin->usb.fd = open(USBdevice, O_RDWR \| O_NOCTTY \| O_NONBLOCK)) == -1)`
		120	`return 0;`
93	andreas	121
101	andreas	122	`if (isatty(garmin->usb.fd))`
		123	`{`
		124	`/* install the signal handler before making the device asynchronous */`
		125	`memset (&saio, 0, sizeof(struct sigaction));`
		126	`saio.sa_handler = signal_handler_IO;`
		127	`/* saio.sa_mask = 0;`
		128	`saio.sa_flags = 0;`
		129	`saio.sa_restorer = NULL; */`
		130	`sigaction(SIGIO, &saio, NULL);`
93	andreas	131
101	andreas	132	`/* allow the process to receive SIGIO */`
		133	`fcntl(garmin->usb.fd, F_SETOWN, getpid());`
		134	`/* Make the file descriptor asynchronous (the manual page says only`
		135	`O_APPEND and O_NONBLOCK, will work with F_SETFL...) */`
		136	`fcntl(garmin->usb.fd, F_SETFL, FASYNC);`
		137	`tcgetattr(garmin->usb.fd, &ttyset_old); /* save current port settings */`
		138	`ttyset.c_cflag &= ~(PARENB \| CRTSCTS);`
		139	`ttyset.c_cflag \|= CREAD \| CLOCAL \| B9600;`
		140	`ttyset.c_iflag = ttyset.c_oflag = ttyset.c_lflag = (tcflag_t) 0;`
		141	`ttyset.c_oflag = (ONLCR);`
93	andreas	142
101	andreas	143	`tcflush(garmin->usb.fd, TCIFLUSH);`
		144	`tcsetattr(garmin->usb.fd, TCSANOW, &ttyset);`
		145	`}`
		146	`else`
		147	`{`
		148	`close(garmin->usb.fd);`
		149	`garmin->usb.fd = -1;`
		150	`return 0;`
		151	`}`
93	andreas	152
101	andreas	153	`return 1;`
		154	`}`
		155	`else if (!method && garmin->usb.handle == NULL)`
		156	`{`
		157	`usb_init();`
		158	`usb_find_busses();`
		159	`usb_find_devices();`
		160
		161	`for ( bi = usb_busses; bi != NULL; bi = bi->next )`
		162	`{`
		163	`for ( di = bi->devices; di != NULL; di = di->next )`
		164	`{`
		165	`if ( di->descriptor.idVendor == GARMIN_USB_VID &&`
		166	`di->descriptor.idProduct == GARMIN_USB_PID )`
		167	`{`
		168
		169	`if ( garmin->verbose != 0 )`
		170	`{`
136	andreas	171	`sprintf(hv0, "[garmin] found VID %04x, PID %04x on %s/%s!",`
101	andreas	172	`di->descriptor.idVendor,`
		173	`di->descriptor.idProduct,`
		174	`bi->dirname,`
		175	`di->filename);`
136	andreas	176	`garmin_queue_error(hv0, err_info);`
101	andreas	177	`}`
		178
		179	`garmin->usb.handle = usb_open(di);`
		180	`garmin->usb.read_bulk = 0;`
		181
		182	`if ( garmin->usb.handle == NULL )`
		183	`{`
136	andreas	184	`sprintf(hv0, "usb_open failed: %s!",usb_strerror());`
		185	`garmin_queue_error(hv0, err_error);`
101	andreas	186	`return 0;`
		187	`}`
		188
136	andreas	189	`if (usb_set_configuration(garmin->usb.handle, 1) < 0 )`
101	andreas	190	`{`
136	andreas	191	`sprintf(hv0, "usb_set_configuration failed: %s!",usb_strerror());`
		192	`garmin_queue_error(hv0, err_error);`
101	andreas	193	`return 0;`
		194	`}`
		195
		196	`if ( usb_claim_interface(garmin->usb.handle,0) < 0 )`
		197	`{`
136	andreas	198	`sprintf(hv0, "usb_claim_interface failed: %s!",usb_strerror());`
		199	`garmin_queue_error(hv0, err_error);`
101	andreas	200	`return 0;`
		201	`}`
		202
		203	`for ( i = 0; i < di->config->interface->altsetting->bNumEndpoints; i++ )`
		204	`{`
		205	`struct usb_endpoint_descriptor * ep;`
		206
		207	`ep = &di->config->interface->altsetting->endpoint[i];`
		208
		209	`switch ( ep->bmAttributes & USB_ENDPOINT_TYPE_MASK )`
		210	`{`
		211	`case USB_ENDPOINT_TYPE_BULK:`
		212	`if ( ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK )`
		213	`{`
		214	`garmin->usb.bulk_in = ep->bEndpointAddress & USB_ENDPOINT_ADDRESS_MASK;`
		215	`}`
		216	`else`
		217	`{`
		218	`garmin->usb.bulk_out = ep->bEndpointAddress & USB_ENDPOINT_ADDRESS_MASK;`
		219	`}`
		220	`break;`
		221
		222	`case USB_ENDPOINT_TYPE_INTERRUPT:`
		223	`if ( ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK )`
		224	`{`
		225	`garmin->usb.intr_in = ep->bEndpointAddress & USB_ENDPOINT_ADDRESS_MASK;`
		226	`}`
		227	`break;`
		228
		229	`default:`
		230	`break;`
		231	`}`
		232	`}`
		233
		234	`break;`
		235	`}`
93	andreas	236	`}`
		237
101	andreas	238	`if ( garmin->usb.handle != NULL )`
		239	`break;`
		240	`}`
136	andreas	241
		242	`garmin_queue_error("Couldn't detect any Garmin device!", err_info);`
93	andreas	243	`}`
		244
101	andreas	245	`return (garmin->usb.handle != NULL);`
93	andreas	246	`}`
		247
101	andreas	248	`void signal_handler_IO (int status)`
		249	`{`
		250	`wait_flag = FALSE;`
		251	`}`
93	andreas	252
101	andreas	253	`int garmin_set_speed(garmin_unit *garmin, unsigned int speed, unsigned int stopbits)`
93	andreas	254	`{`
101	andreas	255	`unsigned int rate;`
		256
		257	`if (speed < 300)`
		258	`rate = B0;`
		259	`else if (speed < 1200)`
		260	`rate = B300;`
		261	`else if (speed < 2400)`
		262	`rate = B1200;`
		263	`else if (speed < 4800)`
		264	`rate = B2400;`
		265	`else if (speed < 9600)`
		266	`rate = B4800;`
		267	`else if (speed < 19200)`
		268	`rate = B9600;`
		269	`else if (speed < 38400)`
		270	`rate = B19200;`
		271	`else if (speed < 57600)`
		272	`rate = B38400;`
		273	`else if (speed < 115200)`
		274	`rate = B57600;`
		275	`else`
		276	`rate = B115200;`
		277
		278	`tcflush(garmin->usb.fd, TCIOFLUSH); /* toss stale data */`
		279
		280	`if (rate != cfgetispeed(&ttyset) \|\| stopbits != 1)`
		281	`{`
		282	`cfsetispeed(&ttyset, (speed_t)rate);`
		283	`cfsetospeed(&ttyset, (speed_t)rate);`
		284	`ttyset.c_cflag &=~ CSIZE;`
		285	`ttyset.c_cflag \|= (CSIZE & (stopbits == 2 ? CS7 : CS8));`
		286
		287	`if (tcsetattr(garmin->usb.fd, TCSANOW, &ttyset) != 0)`
		288	`return 0;`
		289
		290	`tcflush(garmin->usb.fd, TCIOFLUSH);`
		291	`}`
		292
		293	`/* if ((session->packet_type = packet_sniff(session)) == BAD_PACKET)`
		294	`return 0;`
		295	`*/`
		296	`return 1;`
93	andreas	297	`}`
		298
101	andreas	299	`uint8 garmin_packet_type(garmin_packet *p)`
		300	`{`
		301	`return p->packet.type;`
		302	`}`
93	andreas	303
101	andreas	304
		305	`uint16 garmin_packet_id(garmin_packet *p)`
93	andreas	306	`{`
101	andreas	307	`return get_uint16(p->packet.id);`
93	andreas	308	`}`
		309
		310
101	andreas	311	`uint32 garmin_packet_size(garmin_packet *p)`
93	andreas	312	`{`
101	andreas	313	`return get_uint32(p->packet.size);`
93	andreas	314	`}`
		315
		316
101	andreas	317	`uint8 garmin_packet_data(garmin_packet p)`
93	andreas	318	`{`
101	andreas	319	`return p->packet.data;`
93	andreas	320	`}`
		321
		322
101	andreas	323	`int garmin_packetize(garmin_packet p, uint16 id, uint32 size, uint8 data)`
93	andreas	324	`{`
101	andreas	325	`int ok = 0;`
93	andreas	326
101	andreas	327	`if (size + PACKET_HEADER_SIZE < sizeof(garmin_packet))`
		328	`{`
		329	`p->packet.type = GARMIN_PROTOCOL_APP;`
		330	`p->packet.reserved1 = 0;`
		331	`p->packet.reserved2 = 0;`
		332	`p->packet.reserved3 = 0;`
		333	`p->packet.id[0] = id;`
		334	`p->packet.id[1] = id >> 8;`
		335	`p->packet.reserved4 = 0;`
		336	`p->packet.reserved5 = 0;`
		337	`p->packet.size[0] = size;`
		338	`p->packet.size[1] = size >> 8;`
		339	`p->packet.size[2] = size >> 16;`
		340	`p->packet.size[3] = size >> 24;`
93	andreas	341
101	andreas	342	`if ( size > 0 && data != NULL )`
		343	`{`
		344	`memcpy(p->packet.data,data,size);`
		345	`}`
		346
		347	`ok = 1;`
		348	`}`
		349
		350	`return ok;`
93	andreas	351	`}`
		352
		353
101	andreas	354	`int garmin_read(garmin_unit garmin, garmin_packet p)`
93	andreas	355	`{`
101	andreas	356	`int r = -1;`
		357	`int cnt = 0;`
		358	`int bLen = 0;`
		359	`struct timespec delay, rem;`
		360	`fd_set fds, rfds;`
		361	`struct timeval tv;`
		362	`int sel_ret = 0;`
		363	`int ok = 0;`
136	andreas	364	`char hv0[1024];`
93	andreas	365
101	andreas	366	`if (garmin->usb.fd == -1 && garmin->usb.handle == NULL)`
		367	`garmin_open(garmin);`
93	andreas	368
101	andreas	369	`if (method && garmin->usb.fd != -1)`
		370	`{`
		371	`long theBytesReturned = 0;`
		372	`char buf = (char )p->data;`
		373
		374	`for(cnt = 0 ; cnt < 10 ; cnt++)`
		375	`{`
		376	`if (wait_flag != FALSE)`
		377	`{`
		378	`cnt--;`
		379	`usleep (100000);`
		380	`continue;`
		381	`}`
		382
		383	`/* Read async data until the driver returns less than the`
		384	`* max async data size, which signifies the end of a packet`
		385	`* not optimal, but given the speed and packet nature of`
		386	`* the USB not too bad for a start`
		387	`*/`
		388	`wait_flag = TRUE;`
		389
		390	`theBytesReturned = read(garmin->usb.fd, buf + bLen, ASYNC_DATA_SIZE);`
		391
		392	`if (0 > theBytesReturned)`
		393	`{`
		394	`/* read error...`
		395	`* or EAGAIN, but O_NONBLOCK is never set`
		396	`*/`
136	andreas	397	`sprintf(hv0, "Read error=%ld, errno=%d!", theBytesReturned, errno);`
		398	`garmin_queue_error(hv0, err_error);`
101	andreas	399	`continue;`
		400	`}`
		401
136	andreas	402	`sprintf(hv0, "got %ld bytes.", theBytesReturned);`
		403	`garmin_queue_error(hv0, err_info);`
101	andreas	404	`bLen += theBytesReturned;`
		405
		406	`if (theBytesReturned < ASYNC_DATA_SIZE)`
		407	`{`
		408	`/* zero length, or short, read is a flag for got the whole packet */`
		409	`break;`
		410	`}`
		411
		412	`if (256 <= bLen)`
		413	`{`
		414	`/* really bad read error... */`
		415	`bLen = 0;`
136	andreas	416	`garmin_queue_error("Packet too long!", err_fatal);`
101	andreas	417	`break;`
		418	`}`
		419
		420	`delay.tv_sec = 0;`
		421	`delay.tv_nsec = 3330000L;`
		422
		423	`while (nanosleep(&delay, &rem) < 0)`
		424	`continue;`
		425	`}`
		426	`}`
		427	`else if (garmin->usb.handle != NULL)`
		428	`{`
		429	`if (garmin->usb.read_bulk == 0)`
		430	`{`
		431	`r = usb_interrupt_read(garmin->usb.handle,`
93	andreas	432	`garmin->usb.intr_in,`
		433	`p->data,`
		434	`sizeof(garmin_packet),`
		435	`INTR_TIMEOUT);`
101	andreas	436	`/*`
		437	`* If the packet is a "Pid_Data_Available" packet, we need to read`
		438	`* from the bulk endpoint until we get an empty packet.`
		439	`*/`
		440
		441	`if (garmin_packet_type(p) == GARMIN_PROTOCOL_USB &&`
		442	`garmin_packet_id(p) == Pid_Data_Available)`
		443	`{`
		444	`/* FIXME!!! */`
136	andreas	445	`sprintf(hv0, "Received a Pid_Data_Available from the unit!");`
		446	`garmin_queue_error(hv0, err_warning);`
101	andreas	447	`}`
		448	`}`
		449	`else`
		450	`{`
		451	`r = usb_bulk_read(garmin->usb.handle,`
93	andreas	452	`garmin->usb.bulk_in,`
		453	`p->data,`
		454	`sizeof(garmin_packet),`
		455	`BULK_TIMEOUT);`
101	andreas	456	`}`
		457	`}`
93	andreas	458
101	andreas	459	`if (garmin->verbose != 0 && r >= 0)`
		460	`{`
		461	`garmin_print_packet(p, GARMIN_DIR_READ, stdout);`
		462	`}`
93	andreas	463
101	andreas	464	`return r;`
93	andreas	465	`}`
		466
		467
101	andreas	468	`int garmin_write(garmin_unit garmin, garmin_packet p)`
93	andreas	469	`{`
101	andreas	470	`int r = -1;`
		471	`int s = garmin_packet_size(p) + PACKET_HEADER_SIZE;`
93	andreas	472
101	andreas	473	`if (garmin->usb.fd == -1 && garmin->usb.handle == NULL)`
		474	`garmin_open(garmin);`
93	andreas	475
101	andreas	476	`if (garmin->usb.handle != NULL \|\| garmin->usb.fd != -1)`
		477	`{`
		478	`if (garmin->verbose != 0)`
		479	`{`
		480	`garmin_print_packet(p, GARMIN_DIR_WRITE, stdout);`
		481	`}`
93	andreas	482
101	andreas	483	`if (method)`
		484	`r = write(garmin->usb.fd, p->data, s);`
		485	`else`
		486	`r = usb_bulk_write(garmin->usb.handle,`
93	andreas	487	`garmin->usb.bulk_out,`
		488	`p->data,`
		489	`s,`
		490	`BULK_TIMEOUT);`
101	andreas	491
		492	`if (r != s)`
		493	`{`
136	andreas	494	`char hv0[1024];`
		495
101	andreas	496	`if (method)`
136	andreas	497	`{`
		498	`sprintf(hv0, "Write to device failed!");`
		499	`garmin_queue_error(hv0, err_error);`
		500	`}`
101	andreas	501	`else`
136	andreas	502	`{`
		503	`sprintf(stderr, "usb_bulk_write failed: %s!", usb_strerror());`
		504	`garmin_queue_error(hv0, err_error);`
		505	`}`
101	andreas	506
		507	`return 0;`
		508	`}`
		509	`}`
		510
		511	`return r;`
93	andreas	512	`}`
		513
		514
101	andreas	515	`uint32 garmin_start_session(garmin_unit *garmin)`
93	andreas	516	`{`
101	andreas	517	`garmin_packet p;`
		518	`int i;`
		519	`fd_set fds, rfds;`
		520	`struct timeval tv;`
		521	`int sel_ret = 0;`
		522	`int ok = 0;`
93	andreas	523
101	andreas	524	`garmin_packetize(&p, Pid_Start_Session, 0, NULL);`
		525	`p.packet.type = GARMIN_PROTOCOL_USB;`
93	andreas	526
101	andreas	527	`if (method && garmin->usb.fd != -1)`
		528	`{`
		529	`FD_ZERO(&fds);`
		530	`FD_SET(garmin->usb.fd, &fds);`
		531	`}`
93	andreas	532
101	andreas	533	`garmin_write(garmin, &p);`
		534	`garmin_write(garmin, &p);`
		535	`garmin_write(garmin, &p);`
		536
		537	`if (garmin_read(garmin, &p) == 16)`
		538	`{`
		539	`garmin->id = get_uint32(p.packet.data);`
		540	`}`
		541	`else`
		542	`{`
		543	`garmin->id = 0;`
		544	`}`
		545
136	andreas	546	`garmin_callback("start_session");`
101	andreas	547	`return garmin->id;`
93	andreas	548	`}`
		549
		550
101	andreas	551	`void garmin_print_packet(garmin_packet p, int dir, FILE fp)`
93	andreas	552	`{`
101	andreas	553	`int i;`
		554	`int j;`
		555	`uint32 s;`
		556	`char hex[128];`
		557	`char dec[128];`
93	andreas	558
101	andreas	559	`s = garmin_packet_size(p);`
93	andreas	560
101	andreas	561	`switch ( dir )`
		562	`{`
		563	`case GARMIN_DIR_READ: fprintf(fp,"<read"); break;`
		564	`case GARMIN_DIR_WRITE: fprintf(fp,"<write"); break;`
		565	`default: fprintf(fp,"<packet"); break;`
		566	`}`
93	andreas	567
101	andreas	568	`fprintf(fp," type=\"0x%02x\" id=\"0x%04x\" size=\"%u\"",`
93	andreas	569	`garmin_packet_type(p),garmin_packet_id(p),s);`
101	andreas	570
		571	`if (s > 0)`
		572	`{`
		573	`fprintf(fp,">\n");`
		574
		575	`for ( i = 0, j = 0; i < s; i++ )`
		576	`{`
		577	`sprintf(&hex[(3*(i&0x0f))]," %02x",p->packet.data[i]);`
		578	`sprintf(&dec[(i&0x0f)],"%c",`
		579	`(isalnum(p->packet.data[i]) \|\|`
		580	`ispunct(p->packet.data[i]) \|\|`
		581	`p->packet.data[i] == ' ') ?`
		582	`p->packet.data[i] : '_');`
		583
		584	`if ( (i & 0x0f) == 0x0f )`
		585	`{`
		586	`j = 0;`
		587	`fprintf(fp,"[%04x] %-54s %s\n",i-15,hex,dec);`
		588	`}`
		589	`else`
		590	`{`
		591	`j++;`
		592	`}`
		593	`}`
		594
		595	`if (j > 0)`
		596	`{`
		597	`fprintf(fp,"[%04x] %-54s %s\n",s-(s & 0x0f),hex,dec);`
		598	`}`
		599
		600	`switch (dir)`
		601	`{`
		602	`case GARMIN_DIR_READ: fprintf(fp,"</read>\n"); break;`
		603	`case GARMIN_DIR_WRITE: fprintf(fp,"</write>\n"); break;`
		604	`default: fprintf(fp,"</packet>\n"); break;`
		605	`}`
		606	`}`
		607	`else`
		608	`{`
		609	`fprintf(fp,"/>\n");`
		610	`}`
93	andreas	611	`}`

Subversion Repositories public

(root)/sportwatcher/branches/sportwatcher-0.4/libgarmin/usb_comm.c – Rev 136