chose/extra/Fraise/bin/fsusb-0.1.11-2/fsusb.c

/*
** This file is part of fsusb_picdem
**
** fsusb_picdem is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License as
** published by the Free Software Foundation; either version 2 of the
** License, or (at your option) any later version.
**
** fsusb_picdem is distributed in the hope that it will be useful, but
** WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
** General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with fsusb_picdem; if not, write to the Free Software
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
** 02110-1301, USA
*/

/*
** portions from usb_pickit by Orion Sky Lawlor, olawlor@acm.org
*/

#include <usb.h> /* libusb header */
#include <unistd.h> /* for geteuid */
#include <stdio.h>
#include <string.h>
#include "bootload.h"
#include "fsusb.h"


const static int fsusb_vendorID=0x04d8; // Microchip, Inc
const static int fsusb_productID=0x000b; // PICDEM-FS USB
const static int fsusb_configuration=1; /* 1: bootloader
                                         * ### may change in future firmware versions
                                         */
const static int fsusb_interface=0;
const static int fsusb_endpoint=1; /* first endpoint for everything
                                    * ### may change in future firmware versions
                                    */
const static int fsusb_timeout=1000; /* timeout in ms */



void bad(const char *why)
{
  fprintf(stderr,"Fatal error> %s\n",why);
  exit(17);
}



void recv_usb(picdem_handle *d, int len, byte *dest) {
  int r;

  r=usb_bulk_read(d, fsusb_endpoint, dest, len, fsusb_timeout);

  if (r!=len) {
    perror("usb PICDEM read");
    bad("USB read failed");
  }
  //  printf("read %i bytes\n", r);
}



void rjl_request_version(picdem_handle *d, unsigned char *ret)
{
  int r;
  char buf[4];

  // ### "\0\0\0\0\0" may not be correct in future firmware versions
  r=usb_bulk_write(d, fsusb_endpoint, "\0\0\0\0\0", 5, fsusb_timeout);
  if(r != 5) {
    perror("usb_bulk_write");
    bad("rjl_request_version(): USB write failed");
  }

  // command, len, minor, major
  recv_usb(d,4,buf);
  ret[0]=buf[3];
  ret[1]=buf[2];
}



void rjl_request_flash(picdem_handle *d, int offset, int len, bl_packet *pack)
{
  int r;
  bl_packet p;


  p.command=READ_FLASH;
  p.address.low=(offset & 0xff)>>0;
  p.address.high=(offset & 0xff00)>>8;
  p.address.upper=(offset & 0xf0000)>>16;
  p.len=len;


  r=usb_bulk_write(d, fsusb_endpoint, (char*)&p, 5, fsusb_timeout);
  if(r != 5) {
    perror("usb_bulk_write");
    bad("rjl_request_flash(): USB write failed");
  }


  recv_usb(d,len+5,(byte*)pack);
}



/* write in 16-byte boundary-aligned blocks only in this version of
 * the bootloader
 */
void rjl_write_flash(picdem_handle *d, int offset, int len, byte *data, bl_packet *pack)
{
  int r;
  bl_packet p;
  int i;
  byte retbuf[5];



  if(offset & 0x0f) {
    printf("*** WARNING: not boundary-aligned\n");
    return;
  }
  if(len != 16) {
    printf("*** WARNING: not 16 bytes\n");
    return;
  }



  p.command=WRITE_FLASH;
  p.address.low=(offset & 0xff)>>0;
  p.address.high=(offset & 0xff00)>>8;
  p.address.upper=(offset & 0xf0000)>>16;
  p.len=len;
  for(i=0;i<len;i++) {
    p.data[i]=data[i];
  }


  r=usb_bulk_write(d, fsusb_endpoint, (char*)&p, 5+len, fsusb_timeout);
  if(r != 5+len) {
    perror("usb_bulk_write");
    bad("rjl_write_flash(): USB write failed");
  }

  recv_usb(d,1,retbuf);
  //  printf("write reply is %x\n", retbuf[0]);
}



/* write on 64-byte boundaries only in blocks of 64 bytes.
 *  It's a feature.
 */
void rjl_write_block(picdem_handle *d, int offset, byte *data)
{
  int r;
  bl_packet p;
  byte retbuf[5];
  int subblock=0;


  if(offset & 0x3f) {
    printf("*** WARNING: not boundary-aligned\n");
    return;
  }


  p.command=ERASE_FLASH;
  p.address.low=(offset & 0xff)>>0;
  p.address.high=(offset & 0xff00)>>8;
  p.address.upper=(offset & 0xf0000)>>16;
  p.len=1;


  r=usb_bulk_write(d, fsusb_endpoint, (char*)&p, 5, fsusb_timeout);
  if(r != 5) {
    perror("usb_bulk_write");
    bad("rjl_write_block(): USB write failed");
  }


  recv_usb(d,1,retbuf);
  //  printf("erase reply is %x\n", retbuf[0]);


  for(subblock=0;subblock<4;subblock++) {
    p.command=WRITE_FLASH;
    p.address.low=((offset+16*subblock) & 0xff)>>0;
    p.address.high=((offset+16*subblock) & 0xff00)>>8;
    p.address.upper=((offset+16*subblock) & 0xf0000)>>16;
    p.len=16;
    memcpy(p.data, data+(subblock*16), 16);


    r=usb_bulk_write(d, fsusb_endpoint, (char*)&p, 5+16, fsusb_timeout);
    if(r != 5+16) {
      perror("usb_bulk_write");
      bad("rjl_write_block(): USB write failed");
    }


    recv_usb(d,1,retbuf);
    //  printf("write reply is %x\n", retbuf[0]);
  }
}



// 59ish bytes max
void rjl_write_config_block(picdem_handle *d, int offset, int len, byte *data)
{
  int r;
  bl_packet p;
  //  int i;
  byte retbuf[5];


  if(len>=BL_DATA_LEN) {
    printf("*** ERROR: config block too big\n");
    return;
  }



  /* The firmware clips the erase to a 64-byte block, which
   *  we don't worry about because in any real device
   *  the config starts on a 64-byte boundary.
   */
  p.command=ERASE_FLASH;
  p.address.low=(offset & 0xff)>>0;
  p.address.high=(offset & 0xff00)>>8;
  p.address.upper=(offset & 0xf0000)>>16;
  p.len=1;


  r=usb_bulk_write(d, fsusb_endpoint, (char*)&p, 5, fsusb_timeout);
  if(r != 5) {
    perror("usb_bulk_write");
    bad("rjl_write_config_block(): USB write failed");
  }


  recv_usb(d,1,retbuf);
  //  printf("erase reply is %x\n", retbuf[0]);


  // config writes have no alignment restriction
  p.command=WRITE_CONFIG;
  p.address.low=(offset & 0xff)>>0;
  p.address.high=(offset & 0xff00)>>8;
  p.address.upper=(offset & 0xf0000)>>16;
  p.len=len;
  memcpy(p.data, data, len);


  r=usb_bulk_write(d, fsusb_endpoint, (char*)&p, 5+len, fsusb_timeout);
  if(r != 5+len) {
    perror("usb_bulk_write");
    bad("rjl_write_config_block(): USB write failed");
  }


  recv_usb(d,1,retbuf);
  //  printf("write reply is %x\n", retbuf[0]);
}



// write on 64-byte boundaries only in blocks of 64 bytes
void rjl_erase_block(picdem_handle *d, int offset)
{
  int r;
  bl_packet p;
  byte retbuf[5];


  if(offset & 0x3f) {
    printf("*** WARNING: not boundary-aligned\n");
    return;
  }



  p.command=ERASE_FLASH;
  p.address.low=(offset & 0xff)>>0;
  p.address.high=(offset & 0xff00)>>8;
  p.address.upper=(offset & 0xf0000)>>16;
  p.len=1;


  r=usb_bulk_write(d, fsusb_endpoint, (char*)&p, 5, fsusb_timeout);
  if(r != 5) {
    perror("usb_bulk_write");
    bad("rjl_erase_block(): USB write failed");
  }


  recv_usb(d,1,retbuf);
  //  printf("erase reply is %x\n", retbuf[0]);
}



/* Find the first USB device with this vendor and product.
 *  Exits on errors, like if the device couldn't be found. -osl
 *
 * This function is heavily based upon Orion Sky Lawlor's
 *  usb_pickit program, which was a very useful reference
 *  for all the USB stuff.  Thanks!
 */
picdem_handle *rjl_fsusb_open(void)
{
  struct usb_device *device;
  struct usb_bus* bus;
  unsigned char buf[2];


  if (geteuid()!=0) {
    bad("This program must be run as root, or made setuid root");
  }

#ifdef USB_DEBUG
  usb_debug=4; 
#endif

  printf("Locating USB Microchip(tm) PICDEM-FS USB(tm) (vendor 0x%04x/product 0x%04x)\n",
  	fsusb_vendorID,fsusb_productID);
  /* (libusb setup code stolen from John Fremlin's cool "usb-robot") -osl */
  usb_init();
  usb_find_busses();
  usb_find_devices();

  for (bus=usb_busses;bus!=NULL;bus=bus->next) {
    struct usb_device* usb_devices = bus->devices;
    for(device=usb_devices;device!=NULL;device=device->next) {


      if (device->descriptor.idVendor == fsusb_vendorID
          && device->descriptor.idProduct == fsusb_productID) {

        usb_dev_handle *d;
        printf( "Found USB PICDEM-FS USB as device '%s' on USB bus %s\n",
                device->filename,
                device->bus->dirname);
        d=usb_open(device);


        if (d) { /* This is our device-- claim it */
          if (usb_set_configuration(d,fsusb_configuration)) {
            bad("Error setting USB configuration.\n");
          }

          if (usb_claim_interface(d,fsusb_interface)) {
            bad("Claim failed-- the USB PICDEM is in use by another driver.\n"
                "Do a `dmesg` to see which kernel driver has claimed it--\n"
                "You may need to `rmmod hid` or patch your kernel's hid driver.\n");
          }

          rjl_request_version(d, buf);

          printf("Communication established.  Onboard firmware version is %d.%d\n",
                 (int)buf[0],(int)buf[1]);

          if (buf[0]!=0x01u) {
            bad("This PICDEM's version is too new (only support version 1.x !)\n");
          }

          return d;
        } else 
          bad("Open failed for USB device");
      }


      /* else some other vendor's device-- keep looking... -osl*/
    }
  }

  bad("Could not find USB PICDEM device--\n"
      "you might try lsusb to see if it's actually there.");

  return NULL;
}