static int ft245r_set_bitclock(PROGRAMMER * pgm) { int r; int rate = 0; /* bitclock is second. 1us = 0.000001. Max rate for ft232r 750000 */ if(pgm->bitclock) { rate = (uint32_t)(1.0/pgm->bitclock) * 2; } else if (pgm->baudrate) { rate = pgm->baudrate * 2; } else { rate = 150000; /* should work for all ftdi chips and the avr default internal clock of 1MHz */ } if (FT245R_DEBUG) { avrdude_message(MSG_NOTICE2, " ft245r: spi bitclk %d -> ft baudrate %d\n", rate / 2, rate); } r = ftdi_set_baudrate(handle, rate); if (r) { avrdude_message(MSG_INFO, "Set baudrate (%d) failed with error '%s'.\n", rate, ftdi_get_error_string (handle)); return -1; } return 0; }
static int pickit2_program_enable(struct programmer_t * pgm, AVRPART * p) { unsigned char cmd[4]; unsigned char res[4]; if (p->op[AVR_OP_PGM_ENABLE] == NULL) { avrdude_message(MSG_INFO, "program enable instruction not defined for part \"%s\"\n", p->desc); return -1; } memset(cmd, 0, sizeof(cmd)); avr_set_bits(p->op[AVR_OP_PGM_ENABLE], cmd); pgm->cmd(pgm, cmd, res); { int i; avrdude_message(MSG_DEBUG, "program_enable(): sending command. Resp = "); for (i = 0; i < 4; i++) { avrdude_message(MSG_DEBUG, "%x ", (int)res[i]); } avrdude_message(MSG_DEBUG, "\n"); } // check for sync character if (res[2] != cmd[1]) return -2; return 0; }
static int avrdoperFillBuffer(union filedescriptor *fdp) { int bytesPending = reportDataSizes[1]; /* guess how much data is buffered in device */ avrdoperRxPosition = avrdoperRxLength = 0; while(bytesPending > 0){ int len, usbErr, lenIndex = chooseDataSize(bytesPending); unsigned char buffer[128]; len = sizeof(avrdoperRxBuffer) - avrdoperRxLength; /* bytes remaining */ if(reportDataSizes[lenIndex] + 2 > len) /* requested data would not fit into buffer */ break; len = reportDataSizes[lenIndex] + 2; usbErr = usbGetReport(fdp, USB_HID_REPORT_TYPE_FEATURE, lenIndex + 1, (char *)buffer, &len); if(usbErr != 0){ avrdude_message(MSG_INFO, "%s: avrdoperFillBuffer(): %s\n", progname, usbErrorText(usbErr)); return -1; } avrdude_message(MSG_TRACE, "Received %d bytes data chunk of total %d\n", len - 2, buffer[1]); len -= 2; /* compensate for report ID and length byte */ bytesPending = buffer[1] - len; /* amount still buffered */ if(len > buffer[1]) /* cut away padding */ len = buffer[1]; if(avrdoperRxLength + len > sizeof(avrdoperRxBuffer)){ avrdude_message(MSG_INFO, "%s: avrdoperFillBuffer(): internal error: buffer overflow\n", progname); return -1; } memcpy(avrdoperRxBuffer + avrdoperRxLength, buffer + 2, len); avrdoperRxLength += len; } return 0; }
static int wiring_parseextparms(PROGRAMMER * pgm, LISTID extparms) { LNODEID ln; const char *extended_param; int rv = 0; void *mycookie = STK500V2PDATA(pgm)->chained_pdata; for (ln = lfirst(extparms); ln; ln = lnext(ln)) { extended_param = ldata(ln); if (strncmp(extended_param, "snooze=", strlen("snooze=")) == 0) { int newsnooze; if (sscanf(extended_param, "snooze=%i", &newsnooze) != 1 || newsnooze < 0) { avrdude_message(MSG_INFO, "%s: wiring_parseextparms(): invalid snooze time '%s'\n", progname, extended_param); rv = -1; continue; } avrdude_message(MSG_NOTICE2, "%s: wiring_parseextparms(): snooze time set to %d ms\n", progname, newsnooze); WIRINGPDATA(mycookie)->snoozetime = newsnooze; continue; } avrdude_message(MSG_INFO, "%s: wiring_parseextparms(): invalid extended parameter '%s'\n", progname, extended_param); rv = -1; } return rv; }
static int cmd_verbose(PROGRAMMER * pgm, struct avrpart * p, int argc, char * argv[]) { int nverb; char *endp; if (argc != 1 && argc != 2) { avrdude_message(MSG_INFO, "Usage: verbose [<value>]\n"); return -1; } if (argc == 1) { avrdude_message(MSG_INFO, "Verbosity level: %d\n", verbose); return 0; } nverb = strtol(argv[1], &endp, 0); if (endp == argv[2]) { avrdude_message(MSG_INFO, "%s: can't parse verbosity level \"%s\"\n", progname, argv[2]); return -1; } if (nverb < 0) { avrdude_message(MSG_INFO, "%s: verbosity level must be positive: %d\n", progname, nverb); return -1; } verbose = nverb; avrdude_message(MSG_INFO, "New verbosity level: %d\n", verbose); return 0; }
static int do_cmd(PROGRAMMER * pgm, struct avrpart * p, int argc, char * argv[]) { int i; int hold; int len; len = strlen(argv[0]); hold = -1; for (i=0; i<NCMDS; i++) { if (strcasecmp(argv[0], cmd[i].name) == 0) { return cmd[i].func(pgm, p, argc, argv); } else if (strncasecmp(argv[0], cmd[i].name, len)==0) { if (hold != -1) { avrdude_message(MSG_INFO, "%s: command \"%s\" is ambiguous\n", progname, argv[0]); return -1; } hold = i; } } if (hold != -1) return cmd[hold].func(pgm, p, argc, argv); avrdude_message(MSG_INFO, "%s: invalid command \"%s\"\n", progname, argv[0]); return -1; }
static int cmd_sck(PROGRAMMER * pgm, struct avrpart * p, int argc, char * argv[]) { int rc; double v; char *endp; if (argc != 2) { avrdude_message(MSG_INFO, "Usage: sck <value>\n"); return -1; } v = strtod(argv[1], &endp); if (endp == argv[1]) { avrdude_message(MSG_INFO, "%s (sck): can't parse period \"%s\"\n", progname, argv[1]); return -1; } v *= 1e-6; /* Convert from microseconds to seconds. */ if (pgm->set_sck_period == NULL) { avrdude_message(MSG_INFO, "%s (sck): the %s programmer cannot set SCK period\n", progname, pgm->type); return -2; } if ((rc = pgm->set_sck_period(pgm, v)) != 0) { avrdude_message(MSG_INFO, "%s (sck): failed to set SCK period (rc = %d)\n", progname, rc); return -3; } return 0; }
static int cmd_vtarg(PROGRAMMER * pgm, struct avrpart * p, int argc, char * argv[]) { int rc; double v; char *endp; if (argc != 2) { avrdude_message(MSG_INFO, "Usage: vtarg <value>\n"); return -1; } v = strtod(argv[1], &endp); if (endp == argv[1]) { avrdude_message(MSG_INFO, "%s (vtarg): can't parse voltage \"%s\"\n", progname, argv[1]); return -1; } if (pgm->set_vtarget == NULL) { avrdude_message(MSG_INFO, "%s (vtarg): the %s programmer cannot set V[target]\n", progname, pgm->type); return -2; } if ((rc = pgm->set_vtarget(pgm, v)) != 0) { avrdude_message(MSG_INFO, "%s (vtarg): failed to set V[target] (rc = %d)\n", progname, rc); return -3; } return 0; }
static int cmd_sig(PROGRAMMER * pgm, struct avrpart * p, int argc, char * argv[]) { int i; int rc; AVRMEM * m; rc = avr_signature(pgm, p); if (rc != 0) { avrdude_message(MSG_INFO, "error reading signature data, rc=%d\n", rc); } m = avr_locate_mem(p, "signature"); if (m == NULL) { avrdude_message(MSG_INFO, "signature data not defined for device \"%s\"\n", p->desc); } else { fprintf(stdout, "Device signature = 0x"); for (i=0; i<m->size; i++) fprintf(stdout, "%02x", m->buf[i]); fprintf(stdout, "\n\n"); } return 0; }
char * get_usb_string(usb_dev_handle * dev_handle, int index) { char buffer[256]; char * str; int result; if (index == 0) return NULL; result = usb_get_string_simple(dev_handle, index, buffer, sizeof(buffer)-1); if (result < 0) { avrdude_message(MSG_INFO, "%s: Warning: Failed to read USB device string %d: %s\n", progname, index, usb_strerror()); return NULL; } str = malloc(result+1); if (str == NULL) { avrdude_message(MSG_INFO, "%s: Out of memory allocating a string\n", progname); return 0; } memcpy(str, buffer, result); str[result] = '\0'; return str; }
int dfu_upload(struct dfu_dev *dfu, void *ptr, int size) { int result; avrdude_message(MSG_TRACE, "%s: dfu_upload(): issuing control IN message, wIndex = %d, ptr = %p, size = %d\n", progname, wIndex, ptr, size); result = usb_control_msg(dfu->dev_handle, 0x80 | USB_TYPE_CLASS | USB_RECIP_INTERFACE, DFU_UPLOAD, wIndex++, 0, ptr, size, dfu->timeout); if (result < 0) { avrdude_message(MSG_INFO, "%s: Error: DFU_UPLOAD failed: %s\n", progname, usb_strerror()); return -1; } if (result < size) { avrdude_message(MSG_INFO, "%s: Error: DFU_UPLOAD failed: %s\n", progname, "short read"); return -1; } if (result > size) { avrdude_message(MSG_INFO, "%s: Error: Oversize read (should not happen); " "exiting\n", progname); exit(1); } return 0; }
/* taken (modified) from avrdude usbasp.c */ static int usb_open_device(struct usb_dev_handle **device, int vendor, int product) { struct usb_bus *bus; struct usb_device *dev; usb_dev_handle *handle = NULL; int errorCode = USB_ERROR_NOTFOUND; static int didUsbInit = 0; if (!didUsbInit) { didUsbInit = 1; usb_init(); } usb_find_busses(); usb_find_devices(); for (bus=usb_get_busses(); bus; bus=bus->next) { for (dev=bus->devices; dev; dev=dev->next) { DEBUG( "Enumerating device list.. VID: 0x%4.4x, PID: 0x%4.4x\n", dev->descriptor.idVendor, dev->descriptor.idProduct); if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) { /* we need to open the device in order to query strings */ handle = usb_open(dev); if (handle == NULL) { errorCode = USB_ERROR_ACCESS; avrdude_message(MSG_INFO, "%s: Warning: cannot open USB device: %s\n", progname, usb_strerror()); continue; } // return with opened device handle else { avrdude_message(MSG_NOTICE, "Device %p seemed to open OK.\n", handle); if ((errorCode = usb_set_configuration(handle, 1)) < 0) { avrdude_message(MSG_INFO, "Could not set configuration. Error code %d, %s.\n" "You may need to run avrdude as root or set up correct usb port permissions.", errorCode, usb_strerror()); } if ((errorCode = usb_claim_interface(handle, 0)) < 0) { avrdude_message(MSG_INFO, "Could not claim interface. Error code %d, %s\n" "You may need to run avrdude as root or set up correct usb port permissions.", errorCode, usb_strerror()); } errorCode = 0; *device = handle; return 0; } } } } return -1; }
static int pickit2_parseextparams(struct programmer_t * pgm, LISTID extparms) { LNODEID ln; const char *extended_param; int rv = 0; for (ln = lfirst(extparms); ln; ln = lnext(ln)) { extended_param = ldata(ln); if (strncmp(extended_param, "clockrate=", strlen("clockrate=")) == 0) { int clock_rate; if (sscanf(extended_param, "clockrate=%i", &clock_rate) != 1 || clock_rate <= 0) { avrdude_message(MSG_INFO, "%s: pickit2_parseextparms(): invalid clockrate '%s'\n", progname, extended_param); rv = -1; continue; } int clock_period = MIN(1000000 / clock_rate, 255); // max period is 255 clock_rate = (int)(1000000 / (clock_period + 5e-7)); // assume highest speed is 2MHz - should probably check this avrdude_message(MSG_NOTICE2, "%s: pickit2_parseextparms(): clockrate set to 0x%02x\n", progname, clock_rate); PDATA(pgm)->clock_period = clock_period; continue; } if (strncmp(extended_param, "timeout=", strlen("timeout=")) == 0) { int timeout; if (sscanf(extended_param, "timeout=%i", &timeout) != 1 || timeout <= 0) { avrdude_message(MSG_INFO, "%s: pickit2_parseextparms(): invalid timeout '%s'\n", progname, extended_param); rv = -1; continue; } avrdude_message(MSG_NOTICE2, "%s: pickit2_parseextparms(): usb timeout set to 0x%02x\n", progname, timeout); PDATA(pgm)->transaction_timeout = timeout; continue; } avrdude_message(MSG_INFO, "%s: pickit2_parseextparms(): invalid extended parameter '%s'\n", progname, extended_param); rv = -1; } return rv; }
struct dfu_dev * dfu_open(char *port_spec) { struct dfu_dev *dfu; char *bus_name = NULL; char *dev_name = NULL; /* The following USB device spec parsing code was copied from usbtiny.c. The * expected format is "usb:BUS:DEV" where BUS and DEV are the bus and device * names. We stash these away in the dfu_dev structure for the dfu_init() * function, where we actually open the device. */ if (strncmp(port_spec, "usb", 3) != 0) { avrdude_message(MSG_INFO, "%s: Error: " "Invalid port specification \"%s\" for USB device\n", progname, port_spec); return NULL; } if(':' == port_spec[3]) { bus_name = strdup(port_spec + 3 + 1); if (bus_name == NULL) { avrdude_message(MSG_INFO, "%s: Out of memory in strdup\n", progname); return NULL; } dev_name = strchr(bus_name, ':'); if(NULL != dev_name) *dev_name++ = '\0'; } /* Allocate the dfu_dev structure and save the bus_name and dev_name * strings for use in dfu_initialize(). */ dfu = calloc(1, sizeof(struct dfu_dev)); if (dfu == NULL) { avrdude_message(MSG_INFO, "%s: out of memory\n", progname); free(bus_name); return NULL; } dfu->bus_name = bus_name; dfu->dev_name = dev_name; dfu->timeout = DFU_TIMEOUT; /* LibUSB initialization. */ usb_init(); usb_find_busses(); usb_find_devices(); return dfu; }
static int ser_setspeed(union filedescriptor *fd, long baud) { int rc; struct termios termios; speed_t speed = serial_baud_lookup (baud); if (!isatty(fd->ifd)) return -ENOTTY; /* * initialize terminal modes */ rc = tcgetattr(fd->ifd, &termios); if (rc < 0) { avrdude_message(MSG_INFO, "%s: ser_setspeed(): tcgetattr() failed", progname); return -errno; } /* * copy termios for ser_close if we haven't already */ if (! saved_original_termios++) { original_termios = termios; } termios.c_iflag = IGNBRK; termios.c_oflag = 0; termios.c_lflag = 0; termios.c_cflag = (CS8 | CREAD | CLOCAL); termios.c_cc[VMIN] = 1; termios.c_cc[VTIME] = 0; cfsetospeed(&termios, speed); cfsetispeed(&termios, speed); rc = tcsetattr(fd->ifd, TCSANOW, &termios); if (rc < 0) { avrdude_message(MSG_INFO, "%s: ser_setspeed(): tcsetattr() failed\n", progname); return -errno; } /* * Everything is now set up for a local line without modem control * or flow control, so clear O_NONBLOCK again. */ rc = fcntl(fd->ifd, F_GETFL, 0); if (rc != -1) fcntl(fd->ifd, F_SETFL, rc & ~O_NONBLOCK); return 0; }
static int ser_drain(union filedescriptor *fd, int display) { struct timeval timeout; fd_set rfds; int nfds; int rc; unsigned char buf; timeout.tv_sec = 0; timeout.tv_usec = 250000; if (display) { avrdude_message(MSG_INFO, "drain>"); } while (1) { FD_ZERO(&rfds); FD_SET(fd->ifd, &rfds); reselect: nfds = select(fd->ifd + 1, &rfds, NULL, NULL, &timeout); if (nfds == 0) { if (display) { avrdude_message(MSG_INFO, "<drain\n"); } break; } else if (nfds == -1) { if (errno == EINTR) { goto reselect; } else { avrdude_message(MSG_INFO, "%s: ser_drain(): select(): %s\n", progname, strerror(errno)); return -1; } } rc = read(fd->ifd, &buf, 1); if (rc < 0) { avrdude_message(MSG_INFO, "%s: ser_drain(): read error: %s\n", progname, strerror(errno)); return -1; } if (display) { avrdude_message(MSG_INFO, "%02x ", buf); } } return 0; }
static int wiring_open(PROGRAMMER * pgm, char * port) { int timetosnooze; void *mycookie = STK500V2PDATA(pgm)->chained_pdata; union pinfo pinfo; strcpy(pgm->port, port); pinfo.baud = pgm->baudrate ? pgm->baudrate: 115200; serial_open(port, pinfo, &pgm->fd); /* If we have a snoozetime, then we wait and do NOT toggle DTR/RTS */ if (WIRINGPDATA(mycookie)->snoozetime > 0) { timetosnooze = WIRINGPDATA(mycookie)->snoozetime; avrdude_message(MSG_NOTICE2, "%s: wiring_open(): snoozing for %d ms\n", progname, timetosnooze); while (timetosnooze--) usleep(1000); avrdude_message(MSG_NOTICE2, "%s: wiring_open(): done snoozing\n", progname); } else { /* Perform Wiring programming mode RESET. */ /* This effectively *releases* both DTR and RTS. */ /* i.e. both DTR and RTS rise to a HIGH logic level */ /* since they are active LOW signals. */ avrdude_message(MSG_NOTICE2, "%s: wiring_open(): releasing DTR/RTS\n", progname); serial_set_dtr_rts(&pgm->fd, 0); usleep(50*1000); /* After releasing for 50 milliseconds, DTR and RTS */ /* are asserted (i.e. logic LOW) again. */ avrdude_message(MSG_NOTICE2, "%s: wiring_open(): asserting DTR/RTS\n", progname); serial_set_dtr_rts(&pgm->fd, 1); usleep(50*1000); } /* drain any extraneous input */ stk500v2_drain(pgm, 0); if (stk500v2_getsync(pgm) < 0) return -1; return 0; }
static int ser_drain(union filedescriptor *fd, int display) { // int rc; unsigned char buf[10]; BOOL readres; DWORD read; HANDLE hComPort=(HANDLE)fd->pfd; if (hComPort == INVALID_HANDLE_VALUE) { avrdude_message(MSG_INFO, "%s: ser_drain(): port not open\n", progname); return -1; } serial_w32SetTimeOut(hComPort,250); if (display) { avrdude_message(MSG_INFO, "drain>"); } while (1) { readres=ReadFile(hComPort, buf, 1, &read, NULL); if (!readres) { LPVOID lpMsgBuf; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) &lpMsgBuf, 0, NULL ); avrdude_message(MSG_INFO, "%s: ser_drain(): read error: %s\n", progname, (char*)lpMsgBuf); LocalFree( lpMsgBuf ); return -1; } if (read) { // data avail if (display) avrdude_message(MSG_INFO, "%02x ", buf[0]); } else { // no more data if (display) avrdude_message(MSG_INFO, "<drain\n"); break; } } // while return 0; }
static int ser_send(union filedescriptor *fd, const unsigned char * buf, size_t buflen) { #ifdef HAVE_LIBWS2_32 if (serial_over_ethernet) { return net_send(fd, buf, buflen); } #endif size_t len = buflen; unsigned char c='\0'; DWORD written; const unsigned char * b = buf; HANDLE hComPort=(HANDLE)fd->pfd; if (hComPort == INVALID_HANDLE_VALUE) { avrdude_message(MSG_INFO, "%s: ser_send(): port not open\n", progname); return -1; } if (!len) return 0; if (verbose > 3) { avrdude_message(MSG_TRACE, "%s: Send: ", progname); while (len) { c = *b; if (isprint(c)) { avrdude_message(MSG_TRACE, "%c ", c); } else { avrdude_message(MSG_TRACE, ". "); } avrdude_message(MSG_TRACE, "[%02x] ", c); b++; len--; } avrdude_message(MSG_INFO, "\n"); } serial_w32SetTimeOut(hComPort,500); if (!WriteFile (hComPort, buf, buflen, &written, NULL)) { avrdude_message(MSG_INFO, "%s: ser_send(): write error: %s\n", progname, "sorry no info avail"); // TODO return -1; } if (written != buflen) { avrdude_message(MSG_INFO, "%s: ser_send(): size/send mismatch\n", progname); return -1; } return 0; }
void ppi_open(char * port, union filedescriptor *fdp) { int fd; unsigned char v; fd = open(port, O_RDWR); if (fd < 0) { avrdude_message(MSG_INFO, "%s: can't open device \"%s\": %s\n", progname, port, strerror(errno)); fdp->ifd = -1; return; } ppi_claim (fd); /* * Initialize shadow registers */ ppi_shadow_access (fdp, PPIDATA, &v, PPI_READ); ppi_shadow_access (fdp, PPICTRL, &v, PPI_READ); ppi_shadow_access (fdp, PPISTATUS, &v, PPI_READ); fdp->ifd = fd; }
static int pickit2_chip_erase(struct programmer_t * pgm, AVRPART * p) { unsigned char cmd[4]; unsigned char res[4]; if (p->op[AVR_OP_CHIP_ERASE] == NULL) { avrdude_message(MSG_INFO, "chip erase instruction not defined for part \"%s\"\n", p->desc); return -1; } pgm->pgm_led(pgm, ON); memset(cmd, 0, sizeof(cmd)); avr_set_bits(p->op[AVR_OP_CHIP_ERASE], cmd); pgm->cmd(pgm, cmd, res); usleep(p->chip_erase_delay); pgm->initialize(pgm, p); pgm->pgm_led(pgm, OFF); return 0; }
static int cmd_erase(PROGRAMMER * pgm, struct avrpart * p, int argc, char * argv[]) { avrdude_message(MSG_INFO, "%s: erasing chip\n", progname); pgm->chip_erase(pgm, p); return 0; }
static void wiring_setup(PROGRAMMER * pgm) { void *mycookie; /* * First, have STK500v2 backend allocate its own private data. */ stk500v2_setup(pgm); /* * Now prepare our data */ if ((mycookie = malloc(sizeof(struct wiringpdata))) == 0) { avrdude_message(MSG_INFO, "%s: wiring_setup(): Out of memory allocating private data\n", progname); exit(1); } memset(mycookie, 0, sizeof(struct wiringpdata)); WIRINGPDATA(mycookie)->snoozetime = 0; /* * Store our own cookie in a safe place for the time being. */ STK500V2PDATA(pgm)->chained_pdata = mycookie; }
static int ft245r_parseextparms(PROGRAMMER * pgm, LISTID extparms) { LNODEID ln; const char *extended_param; int rv = 0; for (ln = lfirst(extparms); ln; ln = lnext(ln)) { extended_param = ldata(ln); if (strncmp(extended_param, "serial=", strlen("serial=")) == 0) { if (strlen(extended_param) != (strlen("serial=") + 8)){ avrdude_message(MSG_INFO, "%s: ft245r_parseextparms(): serial has invalid length '%s'\n", progname, extended_param); rv = -1; continue; } char serial[9] = {0}; if ((sscanf(extended_param, "serial=%s", serial) != 1) && (strlen(serial) == 8)) { avrdude_message(MSG_INFO, "%s: ft245r_parseextparms(): invalid serial '%s'\n", progname, serial); rv = -1; continue; } if (verbose >= 2) { avrdude_message(MSG_INFO, "%s: ft245r_parseextparms(): serial number parsed as:\n" "%s %s\n", progname, progbuf, serial); } strcpy(pgm->usbsn, serial); continue; } avrdude_message(MSG_INFO, "%s: ft245r_parseextparms(): invalid extended parameter '%s'\n", progname, extended_param); rv = -1; } return rv; }
static int pickit2_open(PROGRAMMER * pgm, char * port) { #if (defined(WIN32NATIVE) && defined(HAVE_LIBHID)) PDATA(pgm)->usb_handle = open_hid(PICKIT2_VID, PICKIT2_PID); if (PDATA(pgm)->usb_handle == INVALID_HANDLE_VALUE) { /* no PICkit2 found */ avrdude_message(MSG_INFO, "%s: error: could not find PICkit2 with vid=0x%x pid=0x%x\n", progname, PICKIT2_VID, PICKIT2_PID); return -1; } else { // get the device description while we're at it short buff[PGM_DESCLEN-1], i; HidD_GetProductString(PDATA(pgm)->usb_handle, buff, PGM_DESCLEN-1); // convert from wide chars, but do not overwrite trailing '\0' memset(&(pgm->type), 0, PGM_DESCLEN); for (i = 0; i < (PGM_DESCLEN-1) && buff[i]; i++) { pgm->type[i] = (char)buff[i]; // TODO what about little/big endian??? } } #else if (usb_open_device(&(PDATA(pgm)->usb_handle), PICKIT2_VID, PICKIT2_PID) < 0) { /* no PICkit2 found */ avrdude_message(MSG_INFO, "%s: error: could not find PICkit2 with vid=0x%x pid=0x%x\n", progname, PICKIT2_VID, PICKIT2_PID); return -1; } #endif if (pgm->ispdelay > 0) { PDATA(pgm)->clock_period = MIN(pgm->ispdelay, 255); } else if (pgm->bitclock > 0.0) { PDATA(pgm)->clock_period = MIN(pgm->bitclock * 1e6, 255); } return 0; }
static int usbdev_recv(union filedescriptor *fd, unsigned char *buf, size_t nbytes) { usb_dev_handle *udev = (usb_dev_handle *)fd->usb.handle; int i, amnt; unsigned char * p = buf; if (udev == NULL) return -1; for (i = 0; nbytes > 0;) { if (buflen <= bufptr) { if (usb_fill_buf(udev, fd->usb.max_xfer, fd->usb.rep, fd->usb.use_interrupt_xfer) < 0) return -1; } amnt = buflen - bufptr > nbytes? nbytes: buflen - bufptr; memcpy(buf + i, usbbuf + bufptr, amnt); bufptr += amnt; nbytes -= amnt; i += amnt; } if (verbose > 4) { avrdude_message(MSG_TRACE2, "%s: Recv: ", progname); while (i) { unsigned char c = *p; if (isprint(c)) { avrdude_message(MSG_TRACE2, "%c ", c); } else { avrdude_message(MSG_TRACE2, ". "); } avrdude_message(MSG_TRACE2, "[%02x] ", c); p++; i--; } avrdude_message(MSG_TRACE2, "\n"); } return 0; }
static int cmd_send(PROGRAMMER * pgm, struct avrpart * p, int argc, char * argv[]) { unsigned char cmd[4], res[4]; char * e; int i; int len; if (pgm->cmd == NULL) { avrdude_message(MSG_INFO, "The %s programmer does not support direct ISP commands.\n", pgm->type); return -1; } if (spi_mode && (pgm->spi == NULL)) { avrdude_message(MSG_INFO, "The %s programmer does not support direct SPI transfers.\n", pgm->type); return -1; } if ((argc > 5) || ((argc < 5) && (!spi_mode))) { avrdude_message(MSG_INFO, spi_mode? "Usage: send <byte1> [<byte2> [<byte3> [<byte4>]]]\n": "Usage: send <byte1> <byte2> <byte3> <byte4>\n"); return -1; } /* number of bytes to write at the specified address */ len = argc - 1; /* load command bytes */ for (i=1; i<argc; i++) { cmd[i-1] = strtoul(argv[i], &e, 0); if (*e || (e == argv[i])) { avrdude_message(MSG_INFO, "%s (send): can't parse byte \"%s\"\n", progname, argv[i]); return -1; } } pgm->err_led(pgm, OFF); if (spi_mode) pgm->spi(pgm, cmd, res, argc-1); else pgm->cmd(pgm, cmd, res); /* * display results */ avrdude_message(MSG_INFO, "results:"); for (i=0; i<len; i++) avrdude_message(MSG_INFO, " %02x", res[i]); avrdude_message(MSG_INFO, "\n"); fprintf(stdout, "\n"); return 0; }
int dfu_abort(struct dfu_dev *dfu) { int result; avrdude_message(MSG_TRACE, "%s: dfu_abort(): issuing control OUT message\n", progname); result = usb_control_msg(dfu->dev_handle, USB_TYPE_CLASS | USB_RECIP_INTERFACE, DFU_ABORT, 0, 0, NULL, 0, dfu->timeout); if (result < 0) { avrdude_message(MSG_INFO, "%s: Error: Failed to reset DFU state: %s\n", progname, usb_strerror()); return -1; } return 0; }
static int ft245r_nopthread_open (struct programmer_t *pgm, char * name) { avrdude_message(MSG_INFO, "%s: error: no pthread support. Please compile again with pthread installed." #if defined(_WIN32) " See http://sourceware.org/pthreads-win32/." #endif "\n", progname); return -1; }
static int net_send(union filedescriptor *fd, const unsigned char * buf, size_t buflen) { LPVOID lpMsgBuf; int rc; const unsigned char *p = buf; size_t len = buflen; if (fd->ifd < 0) { avrdude_message(MSG_NOTICE, "%s: net_send(): connection not open\n", progname); exit(1); } if (!len) { return 0; } if (verbose > 3) { avrdude_message(MSG_TRACE, "%s: Send: ", progname); while (buflen) { unsigned char c = *buf; if (isprint(c)) { avrdude_message(MSG_TRACE, "%c ", c); } else { avrdude_message(MSG_TRACE, ". "); } avrdude_message(MSG_TRACE, "[%02x] ", c); buf++; buflen--; } avrdude_message(MSG_TRACE, "\n"); } while (len) { rc = send(fd->ifd, p, (len > 1024) ? 1024 : len, 0); if (rc < 0) { FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, WSAGetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL); avrdude_message(MSG_INFO, "%s: net_send(): send error: %s\n", progname, (char *)lpMsgBuf); LocalFree(lpMsgBuf); exit(1); } p += rc; len -= rc; } return 0; }