src/edu/berkeley/slipway/FtdiBoard.java

   1 package edu.berkeley.slipway;
   2
   3 import com.ftdi.usb.*;
   4 import com.atmel.fpslic.*;
   5 import edu.berkeley.obits.*;
   6 import org.ibex.util.*;
   7 import java.io.*;
   8 import java.util.*;
   9 import gnu.io.*;
  10
  11 public class FtdiBoard extends Fpslic implements Board {
  12
  13     static {
  14         System.load(new File("build/"+System.mapLibraryName("FtdiUartNative")).getAbsolutePath());
  15     }
  16
  17     private final FpslicBoot chip;
  18     private final DataInputStream in;
  19     private final DataOutputStream out;
  20
  21     public InputStream getInputStream() { return in; }
  22     public OutputStream getOutputStream() { return out; }
  23
  24     public FtdiBoard() throws Exception {
  25         super(24, 24);
  26         chip = new FpslicBoot(new FpslicBootPinsUsb(new FtdiUart(0x6666, 0x3133, 1500 * 1000)));
  27         String bstFile = this.getClass().getName();
  28         bstFile = bstFile.substring(0, bstFile.lastIndexOf('.'));
  29         bstFile = bstFile.replace('.', '/')+"/slipway_drone.bst";
  30         boot(new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream(bstFile)));
  31         in = new DataInputStream(chip.getInputStream());
  32         out = new DataOutputStream(chip.getOutputStream());
  33         for(int i=0; i<255; i++) out.write(0);
  34         out.flush();
  35         init();
  36     }
  37
  38     public void reset() throws IOException { chip.reset(); }
  39
  40     public void boot(Reader r) throws Exception {
  41         chip.selfTest();
  42
  43         int total = 75090/9;
  44         OutputStream os = new ProgressOutputStream("bootstrap bitstream:", chip.getConfigStream(), total);
  45         BufferedReader br = new BufferedReader(r);
  46
  47         int bytes = 0;
  48         while(true) {
  49             String s = br.readLine();
  50             if (s==null) break;
  51             bytes++;
  52             os.write((byte)Integer.parseInt(s, 2));
  53             if ((bytes % 1000)==0) os.flush();
  54         }
  55         os.close();
  56     }
  57
  58
  59     // AvrDrone leftovers //////////////////////////////////////////////////////////////////////////////
  60
  61     private void init() throws IOException {
  62         byte[] bytes = new byte[6];
  63         int i=0;
  64
  65         out.write(0);
  66         out.flush();
  67
  68         // read any crap that might be left in the buffer
  69         while(true) {
  70             System.arraycopy(bytes, 1, bytes, 0, 5);
  71             bytes[5] = in.readByte();
  72             i++;
  73             System.out.print("\rsignature: read \"" + new String(bytes) + "\"                   ");
  74             if (bytes[0] == (byte)'O' &&
  75                 bytes[1] == (byte)'B' &&
  76                 bytes[2] == (byte)'I' &&
  77                 bytes[3] == (byte)'T' &&
  78                 bytes[4] == (byte)'S') {
  79                 System.out.println("\rsignature: got proper signature                  ");
  80                 break;
  81             }
  82         }
  83
  84         // FIXME: what if init() is called twice?
  85         new Thread() {
  86             public void run() {
  87                 while(true) {
  88                     try {
  89                         while(callbacks.size() == 0) Thread.sleep(500);
  90                         byte b = in.readByte();
  91                         ByteCallback bc = (ByteCallback)callbacks.remove(0);
  92                         bc.call(b);
  93                     } catch (Exception e) {
  94                         e.printStackTrace();
  95                     }
  96                 }
  97             }
  98         }.start();
  99     }
 100
 101
 102     // Programming ///////////////////////////////////////////////////////////////////////////////
 103
 104     private byte[][][] cache = new byte[24][][];
 105     public byte mode4(int z, int y, int x) {
 106         if (cache[x]==null) return 0;
 107         if (cache[x][y]==null) return 0;
 108         return cache[x][y][z];
 109     }
 110
 111     public void mode4(int z, int y, int x, int d) {
 112         try {
 113             if (cache[x & 0xff]==null) cache[x & 0xff] = new byte[24][];
 114             if (cache[x & 0xff][y & 0xff]==null) cache[x & 0xff][y & 0xff] = new byte[256];
 115             cache[x & 0xff][y & 0xff][z & 0xff] = (byte)(d & 0xff);
 116
 117             out.writeByte(1);
 118             out.writeByte(z);
 119             out.writeByte(y);
 120             out.writeByte(x);
 121             out.writeByte(d);
 122         } catch (IOException e) {
 123             throw new RuntimeException(e);
 124         }
 125     }
 126
 127     public void flush() { try { out.flush(); } catch (IOException e) { throw new RuntimeException(e); } }
 128
 129
 130     // Callbacks //////////////////////////////////////////////////////////////////////////////
 131
 132     private Vector callbacks = new Vector();
 133
 134     public static abstract class ByteCallback {
 135         public int result;
 136         public abstract void call(byte b) throws Exception;
 137     }
 138
 139     public synchronized int readCount() {
 140         try {
 141             ByteCallback bc = new ByteCallback() {
 142                     public synchronized void call(byte b) throws Exception {
 143                         result =
 144                             ((b & 0xff) << 24) |
 145                             ((in.read() & 0xff) << 16) |
 146                             ((in.read() & 0xff) << 8) |
 147                             ((in.read() & 0xff) << 0);
 148                         this.notify();
 149                     }
 150                 };
 151             synchronized(bc) {
 152                 callbacks.add(bc);
 153                 out.writeByte(3);
 154                 out.flush();
 155                 bc.wait();
 156             }
 157             return bc.result;
 158         } catch (Exception e) { throw new RuntimeException(e); }
 159     }
 160
 161     public synchronized void readBus(ByteCallback bc) throws IOException {
 162         callbacks.add(bc);
 163         out.writeByte(2);
 164         out.flush();
 165     }
 166
 167     public synchronized void readInterrupts(ByteCallback bc) throws IOException {
 168         callbacks.add(bc);
 169         out.writeByte(3);
 170         out.flush();
 171     }
 172
 173
 174     // Util //////////////////////////////////////////////////////////////////////////////
 175
 176     private String pad(int i, String s) { if (s.length()>i) return s; return "0"+pad((i-1),s); }
 177     public static String pad(String s, int i) {
 178         if (s.length() >= i) return s;
 179         return "0"+pad(s, i-1);
 180     }
 181
 182 }